@typespec/http-client-python 0.28.2 → 0.29.0

package/emitter/src/code-model.ts

@@ -25,14 +25,7 @@ import {
   emitPagingHttpMethod,
 } from "./http.js";
 import { PythonSdkContext } from "./lib.js";
-import {
-  KnownTypes,
-  disableGenerationMap,
-  emitEndpointType,
-  getType,
-  simpleTypesMap,
-  typesMap,
-} from "./types.js";
+import { KnownTypes, emitEndpointType, getType } from "./types.js";
 import { emitParamBase, getClientNamespace, getImplementation, getRootNamespace } from "./utils.js";
 
 function emitBasicMethod<TServiceOperation extends SdkServiceOperation>(
@@ -263,7 +256,7 @@ function emitOperationGroups<TServiceOperation extends SdkServiceOperation>(
   // operation has same clientNamespace as the operation group
   for (const og of operationGroups) {
     for (const op of og.operations) {
-      op.clientNamespace = getClientNamespace(context, og.clientNamespace);
+      op.clientNamespace = og.clientNamespace;
     }
   }
 
@@ -366,7 +359,7 @@ export function emitCodeModel(sdkContext: PythonSdkContext) {
       continue;
     }
     // filter out specific models not used in python, e.g., pageable models
-    if (disableGenerationMap.has(model)) {
+    if (sdkContext.__disableGenerationMap.has(model)) {
       continue;
     }
     // filter out core models
@@ -391,7 +384,7 @@ export function emitCodeModel(sdkContext: PythonSdkContext) {
   }
 
   // clear usage when a model is only used by paging
-  for (const type of typesMap.values()) {
+  for (const type of sdkContext.__typesMap.values()) {
     if (
       type["type"] === "model" &&
       type["referredByOperationType"] === ReferredByOperationTypes.PagingOnly &&
@@ -402,11 +395,12 @@ export function emitCodeModel(sdkContext: PythonSdkContext) {
   }
 
   codeModel["types"] = [
-    ...typesMap.values(),
+    ...sdkContext.__typesMap.values(),
     ...Object.values(KnownTypes),
-    ...simpleTypesMap.values(),
+    ...sdkContext.__simpleTypesMap.values(),
   ];
   codeModel["crossLanguagePackageId"] = ignoreDiagnostics(getCrossLanguagePackageId(sdkContext));
+  codeModel["crossLanguageVersion"] = sdkContext.sdkPackage.crossLanguageVersion;
   if ((sdkContext.emitContext.options as any).flavor === "azure") {
     const metadata = { ...sdkPackage.metadata } as any;
     if (metadata.apiVersions) {

package/emitter/src/constants.ts

@@ -0,0 +1,27 @@
+export const PYODIDE_VERSION = "0.26.2";
+export const PYGEN_WHEEL_FILENAME = "pygen-0.1.0-py3-none-any.whl";
+export const BLOB_STORAGE_BASE_URL = "https://typespec.blob.core.windows.net/pkgs";
+export const PACKAGE_NAME = "@typespec/http-client-python";
+
+export const blackExcludeDirs = [
+  "__pycache__/",
+  "node_modules/",
+  "venv/",
+  "env/",
+  ".direnv",
+  ".eggs",
+  ".git",
+  ".hg",
+  ".tox",
+  ".venv",
+  ".eggs",
+  ".mypy_cache",
+  ".pytest_cache",
+  ".vscode",
+  ".*_build/",
+  "/build/",
+  "dist",
+  ".nox",
+  ".svn",
+  "TempTypeSpecFiles/",
+];

package/emitter/src/emitter.ts

@@ -1,18 +1,30 @@
 import { createSdkContext } from "@azure-tools/typespec-client-generator-core";
-import { EmitContext, NoTarget } from "@typespec/compiler";
+import { EmitContext, emitFile, joinPaths, NoTarget } from "@typespec/compiler";
 import { execSync } from "child_process";
 import fs from "fs";
+import jsyaml from "js-yaml";
 import os from "os";
 import path, { dirname } from "path";
-import { loadPyodide } from "pyodide";
+import { loadPyodide, PyodideInterface } from "pyodide";
 import { fileURLToPath } from "url";
+import pkgJson from "../../package.json" with { type: "json" };
 import { emitCodeModel } from "./code-model.js";
+import {
+  blackExcludeDirs,
+  BLOB_STORAGE_BASE_URL,
+  PACKAGE_NAME,
+  PYGEN_WHEEL_FILENAME,
+  PYODIDE_VERSION,
+} from "./constants.js";
 import { saveCodeModelAsYaml } from "./external-process.js";
 import { PythonEmitterOptions, PythonSdkContext, reportDiagnostic } from "./lib.js";
 import { runPython3 } from "./run-python3.js";
-import { disableGenerationMap, simpleTypesMap, typesMap } from "./types.js";
 import { getRootNamespace, md2Rst } from "./utils.js";
 
+function getBrowserPygenWheelUrl(): string {
+  return `${BLOB_STORAGE_BASE_URL}/${PACKAGE_NAME}/${pkgJson.version}/generator/dist/${PYGEN_WHEEL_FILENAME}`;
+}
+
 function addDefaultOptions(sdkContext: PythonSdkContext) {
   const defaultOptions = {
     "package-version": "1.0.0b1",
@@ -30,21 +42,24 @@ function addDefaultOptions(sdkContext: PythonSdkContext) {
     const packageName = namespace.replace(/\./g, "-");
     options["package-name"] = packageName;
   }
-  if ((options as any).flavor !== "azure") {
-    // if they pass in a flavor other than azure, we want to ignore the value
-    (options as any).flavor = undefined;
-  }
+  // Set flavor based on namespace or passed option
   if (getRootNamespace(sdkContext).toLowerCase().includes("azure")) {
     (options as any).flavor = "azure";
+  } else if ((options as any).flavor !== "azure") {
+    // Explicitly set unbranded flavor when not azure
+    (options as any).flavor = "unbranded";
   }
 
   if (
     options["package-pprint-name"] !== undefined &&
     !options["package-pprint-name"].startsWith('"')
   ) {
-    options["package-pprint-name"] = options["use-pyodide"]
-      ? `${options["package-pprint-name"]}`
-      : `"${options["package-pprint-name"]}"`;
+    // Only add quotes for shell compatibility when NOT using emit-yaml-only mode
+    // (emit-yaml-only passes options via JSON config files, not shell)
+    const needsShellQuoting = !options["use-pyodide"] && !options["emit-yaml-only"];
+    options["package-pprint-name"] = needsShellQuoting
+      ? `"${options["package-pprint-name"]}"`
+      : `${options["package-pprint-name"]}`;
   }
 }
 
@@ -59,6 +74,9 @@ async function createPythonSdkContext(
   return {
     ...sdkContext,
     __endpointPathParameters: [],
+    __typesMap: new Map(),
+    __simpleTypesMap: new Map(),
+    __disableGenerationMap: new Set(),
   };
 }
 
@@ -100,10 +118,58 @@ function walkThroughNodes(yamlMap: Record<string, any>): Record<string, any> {
   return yamlMap;
 }
 
-function cleanAllCache() {
-  typesMap.clear();
-  simpleTypesMap.clear();
-  disableGenerationMap.clear();
+const pyodideGenerationCode = `
+async def main():
+  import warnings
+  with warnings.catch_warnings():
+    from pygen import preprocess, codegen, black
+  preprocess.PreProcessPlugin(output_folder=outputFolder, tsp_file=yamlFile, **commandArgs).process()
+  codegen.CodeGenerator(output_folder=outputFolder, tsp_file=yamlFile, **commandArgs).process()
+  black.BlackScriptPlugin(output_folder=outputFolder, **commandArgs).process()
+
+await main()`;
+
+async function runPyodideGeneration(
+  pyodide: PyodideInterface,
+  outputFolder: string,
+  yamlFile: string,
+  commandArgs: Record<string, string>,
+) {
+  const globals = pyodide.toPy({
+    outputFolder,
+    yamlFile,
+    commandArgs,
+  });
+
+  await pyodide.runPythonAsync(pyodideGenerationCode, { globals });
+}
+
+async function copyPyodideOutputToHost(
+  context: EmitContext<PythonEmitterOptions>,
+  pyodide: PyodideInterface,
+  memfsDir: string,
+  relativeDir: string = "",
+) {
+  const entries = pyodide.FS.readdir(memfsDir).filter(
+    (entry: string) => entry !== "." && entry !== "..",
+  );
+
+  for (const entry of entries) {
+    const memfsPath = `${memfsDir}/${entry}`;
+    const relativePath = relativeDir ? `${relativeDir}/${entry}` : entry;
+    const stats = pyodide.FS.stat(memfsPath);
+
+    if (pyodide.FS.isDir(stats.mode)) {
+      await copyPyodideOutputToHost(context, pyodide, memfsPath, relativePath);
+      continue;
+    }
+
+    const content = pyodide.FS.readFile(memfsPath, { encoding: "utf8" });
+    await emitFile(context.program, {
+      path: joinPaths(context.emitterOutputDir, relativePath),
+      content,
+    });
+  }
 }
 
 export async function $onEmit(context: EmitContext<PythonEmitterOptions>) {
@@ -124,18 +190,23 @@ export async function $onEmit(context: EmitContext<PythonEmitterOptions>) {
 }
 
 async function onEmitMain(context: EmitContext<PythonEmitterOptions>) {
-  // clean all cache to make sure emitter could work in watch mode
-  cleanAllCache();
-
   const program = context.program;
   const sdkContext = await createPythonSdkContext(context);
-  const root = path.join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+
   const outputDir = context.emitterOutputDir;
   addDefaultOptions(sdkContext);
   const yamlMap = emitCodeModel(sdkContext);
   const parsedYamlMap = walkThroughNodes(yamlMap);
 
-  const yamlPath = await saveCodeModelAsYaml("python-yaml-path", parsedYamlMap);
+  // Python emitter requires an SDK client in the TypeSpec
+  if (sdkContext.sdkPackage.clients.length === 0) {
+    reportDiagnostic(program, {
+      code: "no-sdk-clients",
+      target: NoTarget,
+    });
+    return;
+  }
+
   const resolvedOptions = sdkContext.emitContext.options;
   const commandArgs: Record<string, string> = {};
   if (resolvedOptions["packaging-files-config"]) {
@@ -162,99 +233,141 @@ async function onEmitMain(context: EmitContext<PythonEmitterOptions>) {
   commandArgs["from-typespec"] = "true";
   commandArgs["models-mode"] = (resolvedOptions as any)["models-mode"] ?? "dpg";
 
-  if (!program.compilerOptions.noEmit && !program.hasError()) {
-    // if not using pyodide and there's no venv, we try to create venv
-    if (!resolvedOptions["use-pyodide"] && !fs.existsSync(path.join(root, "venv"))) {
-      try {
-        await runPython3(path.join(root, "/eng/scripts/setup/install.py"));
-        await runPython3(path.join(root, "/eng/scripts/setup/prepare.py"));
-      } catch (error) {
-        // if the python env is not ready, we use pyodide instead
-        resolvedOptions["use-pyodide"] = true;
-      }
+  if (typeof window !== "undefined") {
+    // Running in browser with Pyodide - fileURLToPath and other filesystem operations are browser-incompatible
+    const pyodide = await browserPyodidePromise;
+
+    if (!pyodide) {
+      reportDiagnostic(program, {
+        code: "browser-runtime-load-failed",
+        target: NoTarget,
+        format: { details: "" },
+      });
+      return;
     }
 
-    if (resolvedOptions["use-pyodide"]) {
-      // here we run with pyodide
-      const pyodide = await setupPyodideCall(root);
-      // create the output folder if not exists
-      if (!fs.existsSync(outputDir)) {
-        fs.mkdirSync(outputDir, { recursive: true });
+    const yamlFilePath = "/yaml/python-yaml-path.yaml";
+    pyodide.FS.mkdirTree("/yaml");
+    pyodide.FS.mkdirTree("/output");
+    clearMemfsDirectory(pyodide, "/output");
+    pyodide.FS.writeFile(yamlFilePath, jsyaml.dump(parsedYamlMap));
+
+    await runPyodideGeneration(pyodide, "/output", yamlFilePath, commandArgs);
+    await copyPyodideOutputToHost(context, pyodide, "/output");
+  } else {
+    const root = path.join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+    const yamlPath = await saveCodeModelAsYaml("python-yaml-path", parsedYamlMap);
+
+    if (!program.compilerOptions.noEmit && !program.hasError()) {
+      // If emit-yaml-only mode, just copy YAML to output dir for batch processing
+      if (resolvedOptions["emit-yaml-only"]) {
+        if (!fs.existsSync(outputDir)) {
+          fs.mkdirSync(outputDir, { recursive: true });
+        }
+        // Copy YAML to output dir with command args embedded
+        // Use unique filename to avoid conflicts when multiple specs share output dir
+        const configId = path.basename(yamlPath, ".yaml");
+        const batchConfig = { yamlPath, commandArgs, outputDir };
+        fs.writeFileSync(
+          path.join(outputDir, `.tsp-codegen-${configId}.json`),
+          JSON.stringify(batchConfig, null, 2),
+        );
+        return;
       }
-      // mount output folder to pyodide
-      pyodide.FS.mkdirTree("/output");
-      pyodide.FS.mount(pyodide.FS.filesystems.NODEFS, { root: outputDir }, "/output");
-      // mount yaml file to pyodide
-      pyodide.FS.mkdirTree("/yaml");
-      pyodide.FS.mount(pyodide.FS.filesystems.NODEFS, { root: path.dirname(yamlPath) }, "/yaml");
-      const globals = pyodide.toPy({
-        outputFolder: "/output",
-        yamlFile: `/yaml/${path.basename(yamlPath)}`,
-        commandArgs,
-      });
-      const pythonCode = `
-          async def main():
-            import warnings
-            with warnings.catch_warnings():
-              from pygen import preprocess, codegen, black
-            preprocess.PreProcessPlugin(output_folder=outputFolder, tsp_file=yamlFile, **commandArgs).process()
-            codegen.CodeGenerator(output_folder=outputFolder, tsp_file=yamlFile, **commandArgs).process()
-            black.BlackScriptPlugin(output_folder=outputFolder, **commandArgs).process()
-      
-          await main()`;
-      await pyodide.runPythonAsync(pythonCode, { globals });
-    } else {
-      // here we run with native python
-      let venvPath = path.join(root, "venv");
-      if (fs.existsSync(path.join(venvPath, "bin"))) {
-        venvPath = path.join(venvPath, "bin", "python");
-      } else if (fs.existsSync(path.join(venvPath, "Scripts"))) {
-        venvPath = path.join(venvPath, "Scripts", "python.exe");
+      // if not using pyodide and there's no venv, we try to create venv
+      if (!resolvedOptions["use-pyodide"] && !fs.existsSync(path.join(root, "venv"))) {
+        try {
+          await runPython3(path.join(root, "/eng/scripts/setup/install.py"));
+          await runPython3(path.join(root, "/eng/scripts/setup/prepare.py"));
+        } catch {
+          // if the python env is not ready, we use pyodide instead
+          resolvedOptions["use-pyodide"] = true;
+        }
+      }
+
+      if (resolvedOptions["use-pyodide"]) {
+        // here we run with pyodide
+        const pyodide = await setupPyodideCall(root);
+        // create the output folder if not exists
+        if (!fs.existsSync(outputDir)) {
+          fs.mkdirSync(outputDir, { recursive: true });
+        }
+        // mount output folder to pyodide
+        pyodide.FS.mkdirTree("/output");
+        pyodide.FS.mount(pyodide.FS.filesystems.NODEFS, { root: outputDir }, "/output");
+        // mount yaml file to pyodide
+        pyodide.FS.mkdirTree("/yaml");
+        pyodide.FS.mount(pyodide.FS.filesystems.NODEFS, { root: path.dirname(yamlPath) }, "/yaml");
+        await runPyodideGeneration(
+          pyodide,
+          "/output",
+          `/yaml/${path.basename(yamlPath)}`,
+          commandArgs,
+        );
       } else {
-        reportDiagnostic(program, {
-          code: "pyodide-flag-conflict",
-          target: NoTarget,
-        });
+        // here we run with native python
+        let venvPath = path.join(root, "venv");
+        if (fs.existsSync(path.join(venvPath, "bin"))) {
+          venvPath = path.join(venvPath, "bin", "python");
+        } else if (fs.existsSync(path.join(venvPath, "Scripts"))) {
+          venvPath = path.join(venvPath, "Scripts", "python.exe");
+        } else {
+          reportDiagnostic(program, {
+            code: "pyodide-flag-conflict",
+            target: NoTarget,
+          });
+        }
+        commandArgs["output-folder"] = outputDir;
+        commandArgs["tsp-file"] = yamlPath;
+        const commandFlags = Object.entries(commandArgs)
+          .map(([key, value]) => `--${key}=${value}`)
+          .join(" ");
+        const command = `${venvPath} ${root}/eng/scripts/setup/run_tsp.py ${commandFlags}`;
+        execSync(command);
+
+        const excludePattern = blackExcludeDirs.join("|");
+        execSync(
+          `${venvPath} -m black --line-length=120 --quiet --fast ${outputDir} --exclude "${excludePattern}"`,
+        );
+        await checkForPylintIssues(outputDir, excludePattern);
       }
-      commandArgs["output-folder"] = outputDir;
-      commandArgs["tsp-file"] = yamlPath;
-      const commandFlags = Object.entries(commandArgs)
-        .map(([key, value]) => `--${key}=${value}`)
-        .join(" ");
-      const command = `${venvPath} ${root}/eng/scripts/setup/run_tsp.py ${commandFlags}`;
-      execSync(command);
-
-      const blackExcludeDirs = [
-        "__pycache__/",
-        "node_modules/",
-        "venv/",
-        "env/",
-        ".direnv",
-        ".eggs",
-        ".git",
-        ".hg",
-        ".tox",
-        ".venv",
-        ".eggs",
-        ".mypy_cache",
-        ".pytest_cache",
-        ".vscode",
-        ".*_build/",
-        "/build/",
-        "dist",
-        ".nox",
-        ".svn",
-        "TempTypeSpecFiles/",
-      ];
-      const excludePattern = blackExcludeDirs.join("|");
-      execSync(
-        `${venvPath} -m black --line-length=120 --quiet --fast ${outputDir} --exclude "${excludePattern}"`,
-      );
-      checkForPylintIssues(outputDir, excludePattern);
     }
   }
 }
 
+const browserPyodidePromise: Promise<PyodideInterface> | null =
+  typeof window !== "undefined" ? setupPyodideCallBrowser() : null;
+
+function clearMemfsDirectory(pyodide: PyodideInterface, dir: string): void {
+  const entries: string[] = pyodide.FS.readdir(dir).filter(
+    (entry: string) => entry !== "." && entry !== "..",
+  );
+  for (const entry of entries) {
+    const fullPath = `${dir}/${entry}`;
+    const stats = pyodide.FS.stat(fullPath);
+    if (pyodide.FS.isDir(stats.mode)) {
+      clearMemfsDirectory(pyodide, fullPath);
+      pyodide.FS.rmdir(fullPath);
+    } else {
+      pyodide.FS.unlink(fullPath);
+    }
+  }
+}
+
+async function setupPyodideCallBrowser() {
+  const pyodide = await loadPyodide({
+    indexURL: `https://cdn.jsdelivr.net/pyodide/v${PYODIDE_VERSION}/full/`,
+  });
+
+  // use default MEMFS for browser, since NODEFS is not supported
+  pyodide.FS.mkdirTree("/generator");
+  await pyodide.loadPackage("micropip");
+  const micropip = pyodide.pyimport("micropip");
+  await micropip.install(getBrowserPygenWheelUrl());
+
+  return pyodide;
+}
+
 async function setupPyodideCall(root: string) {
   const pyodide = await loadPyodide({
     indexURL: path.dirname(fileURLToPath(import.meta.resolve("pyodide"))),
@@ -269,7 +382,7 @@ async function setupPyodideCall(root: string) {
         if (lockAge > 300) {
           fs.unlinkSync(micropipLockPath);
         }
-      } catch (err) {
+      } catch {
         // ignore
       }
     }
@@ -284,18 +397,18 @@ async function setupPyodideCall(root: string) {
       );
       await pyodide.loadPackage("micropip");
       const micropip = pyodide.pyimport("micropip");
-      await micropip.install("emfs:/generator/dist/pygen-0.1.0-py3-none-any.whl");
+      await micropip.install(`emfs:/generator/dist/${PYGEN_WHEEL_FILENAME}`);
       fs.closeSync(fd);
       fs.unlinkSync(micropipLockPath);
       break;
-    } catch (err) {
+    } catch {
       await new Promise((resolve) => setTimeout(resolve, 1000));
     }
   }
   return pyodide;
 }
 
-function checkForPylintIssues(outputDir: string, excludePattern: string) {
+async function checkForPylintIssues(outputDir: string, excludePattern: string) {
   const excludeRegex = new RegExp(excludePattern);
 
   const shouldExcludePath = (filePath: string): boolean => {
@@ -304,9 +417,8 @@ function checkForPylintIssues(outputDir: string, excludePattern: string) {
     return excludeRegex.test(normalizedPath);
   };
 
-  const processFile = (filePath: string) => {
-    let fileContent;
-    fileContent = fs.readFileSync(filePath, "utf-8");
+  const processFile = async (filePath: string) => {
+    let fileContent = await fs.promises.readFile(filePath, "utf-8");
     const pylintDisables: string[] = [];
     const lineEnding = fileContent.includes("\r\n") && os.platform() === "win32" ? "\r\n" : "\n";
     const lines: string[] = fileContent.split(lineEnding);
@@ -321,32 +433,38 @@ function checkForPylintIssues(outputDir: string, excludePattern: string) {
         fileContent = lines[0].includes("pylint: disable=")
           ? [lines[0] + "," + pylintDisables.join(",")].concat(lines.slice(1)).join(lineEnding)
           : `# pylint: disable=${pylintDisables.join(",")}${lineEnding}` + fileContent;
+        await fs.promises.writeFile(filePath, fileContent);
       }
     }
-
-    fs.writeFileSync(filePath, fileContent);
   };
 
-  const walkDir = (dir: string) => {
+  const collectPythonFiles = async (dir: string): Promise<string[]> => {
     if (shouldExcludePath(dir)) {
-      return;
+      return [];
     }
 
-    const files = fs.readdirSync(dir);
-    files.forEach((file) => {
-      const filePath = path.join(dir, file);
+    const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+
+    const promises = entries.map(async (entry) => {
+      const filePath = path.join(dir, entry.name);
 
       if (shouldExcludePath(filePath)) {
-        return;
+        return [];
       }
 
-      if (fs.statSync(filePath).isDirectory()) {
-        walkDir(filePath);
-      } else if (file.endsWith(".py")) {
-        processFile(filePath);
+      if (entry.isDirectory()) {
+        return collectPythonFiles(filePath);
+      } else if (entry.name.endsWith(".py")) {
+        return [filePath];
       }
+      return [];
     });
+
+    const results = await Promise.all(promises);
+    return results.flat();
   };
 
-  walkDir(outputDir);
+  // Collect all Python files first, then process in parallel
+  const pythonFiles = await collectPythonFiles(outputDir);
+  await Promise.all(pythonFiles.map(processFile));
 }

package/emitter/src/http.ts

@@ -1,4 +1,4 @@
-import { NoTarget } from "@typespec/compiler";
+import { getNamespaceFullName, NoTarget } from "@typespec/compiler";
 
 import {
   getHttpOperationParameter,
@@ -19,6 +19,7 @@ import {
   SdkQueryParameter,
   SdkServiceMethod,
   SdkServiceResponseHeader,
+  SdkType,
   UsageFlags,
 } from "@azure-tools/typespec-client-generator-core";
 import { HttpStatusCodeRange } from "@typespec/http";
@@ -41,6 +42,32 @@ export enum ReferredByOperationTypes {
   NonPagingOnly = 2,
 }
 
+function isEtagType(type: SdkType): boolean {
+  if (type.kind === "nullable") return isEtagType(type.type);
+  const raw = type.__raw;
+  if (!raw || raw.kind !== "Scalar") return false;
+  return (
+    raw.name === "eTag" &&
+    raw.namespace !== undefined &&
+    getNamespaceFullName(raw.namespace) === "Azure.Core"
+  );
+}
+
+function getEtagRole(parameter: SdkHeaderParameter): string | undefined {
+  const name = parameter.name.toLowerCase();
+  const wire = parameter.serializedName.toLowerCase();
+  // Standard If-Match / If-None-Match headers work with any type
+  if (wire === "if-match") return "ifMatch";
+  if (wire === "if-none-match") return "ifNoneMatch";
+  // Non-standard headers require Azure.Core.eTag type
+  if (!isEtagType(parameter.type)) return undefined;
+  if (name.includes("nonematch") || name.includes("none_match")) return "ifNoneMatch";
+  if (name.includes("match")) return "ifMatch";
+  if (wire.endsWith("-if-none-match")) return "ifNoneMatch";
+  if (wire.endsWith("-if-match")) return "ifMatch";
+  return undefined;
+}
+
 function isContentTypeParameter(parameter: SdkHeaderParameter) {
   return parameter.serializedName.toLowerCase() === "content-type";
 }
@@ -496,6 +523,7 @@ function emitHttpHeaderParameter(
     delimiter,
     explode,
     clientDefaultValue,
+    etagRole: getEtagRole(parameter),
   };
 }