@workos/oagen-emitters 0.5.0 → 0.6.1

package/dist/plugin.mjs

@@ -1,2 +1,2 @@
-import { t as workosEmittersPlugin } from "./plugin-BSop9f9z.mjs";
+import { t as workosEmittersPlugin } from "./plugin-CZc7Teko.mjs";
 export { workosEmittersPlugin };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workos/oagen-emitters",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "description": "WorkOS' oagen emitters",
   "license": "MIT",
   "author": "WorkOS",
@@ -40,20 +40,20 @@
   "devDependencies": {
     "@commitlint/cli": "^20.5.0",
     "@commitlint/config-conventional": "^20.5.0",
-    "@types/node": "^25.3.3",
+    "@types/node": "^25.6.0",
     "husky": "^9.1.7",
-    "oxfmt": "^0.45.0",
-    "oxlint": "^1.51.0",
-    "prettier": "^3.8.1",
-    "tsdown": "^0.21.5",
-    "tsx": "^4.19.0",
-    "typescript": "^6.0.0-dev.20260324",
-    "vitest": "^3.0.0"
+    "oxfmt": "^0.46.0",
+    "oxlint": "^1.61.0",
+    "prettier": "^3.8.3",
+    "tsdown": "^0.21.10",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.5"
   },
   "engines": {
     "node": ">=24.10.0"
   },
   "dependencies": {
-    "@workos/oagen": "^0.7.0"
+    "@workos/oagen": "^0.9.0"
   }
 }

package/smoke/sdk-dotnet.ts

@@ -152,15 +152,21 @@ function createProxyServer(apiKey: string, captures: ProxyCapture[]): Promise<{
 // ---------------------------------------------------------------------------
 
 function loadManifest(sdkPath: string): Map<string, ManifestEntry> | null {
-  const manifestPath = resolve(sdkPath, 'smoke-manifest.json');
+  const manifestPath = resolve(sdkPath, '.oagen-manifest.json');
   if (!existsSync(manifestPath)) {
-    console.warn(`Warning: No smoke-manifest.json found at ${manifestPath}`);
-    console.warn('  Method resolution will rely on heuristic tiers — most operations may be skipped.');
+    console.warn(`Warning: No .oagen-manifest.json found at ${manifestPath}`);
+    console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
+    return null;
+  }
+  const parsed = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+  const operations = parsed?.operations;
+  if (!operations || typeof operations !== 'object') {
+    console.warn('Warning: .oagen-manifest.json has no operations field');
+    console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
     return null;
   }
-  const raw = JSON.parse(readFileSync(manifestPath, 'utf-8'));
   const manifest = new Map<string, ManifestEntry>();
-  for (const [httpKey, entry] of Object.entries(raw)) {
+  for (const [httpKey, entry] of Object.entries(operations)) {
     manifest.set(httpKey, entry as ManifestEntry);
   }
   return manifest;

package/smoke/sdk-elixir.ts

@@ -196,15 +196,21 @@ function startProxy(
 // ---------------------------------------------------------------------------
 
 function loadManifest(sdkPath: string): Map<string, ManifestEntry> | null {
-  const manifestPath = resolve(sdkPath, 'smoke-manifest.json');
+  const manifestPath = resolve(sdkPath, '.oagen-manifest.json');
   if (!existsSync(manifestPath)) {
-    console.warn(`Warning: No smoke-manifest.json found at ${manifestPath}`);
-    console.warn('  Method resolution will rely on heuristic tiers — most operations may be skipped.');
+    console.warn(`Warning: No .oagen-manifest.json found at ${manifestPath}`);
+    console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
+    return null;
+  }
+  const parsed = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+  const operations = parsed?.operations;
+  if (!operations || typeof operations !== 'object') {
+    console.warn('Warning: .oagen-manifest.json has no operations field');
+    console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
     return null;
   }
-  const raw = JSON.parse(readFileSync(manifestPath, 'utf-8'));
   const manifest = new Map<string, ManifestEntry>();
-  for (const [httpKey, entry] of Object.entries(raw)) {
+  for (const [httpKey, entry] of Object.entries(operations)) {
     manifest.set(httpKey, entry as ManifestEntry);
   }
   return manifest;

package/smoke/sdk-go.ts

@@ -126,15 +126,21 @@ function goFieldName(name: string): string {
 // ---------------------------------------------------------------------------
 
 function loadManifest(sdkPath: string): Map<string, ManifestEntry> | null {
-  const manifestPath = resolve(sdkPath, 'smoke-manifest.json');
+  const manifestPath = resolve(sdkPath, '.oagen-manifest.json');
   if (!existsSync(manifestPath)) {
-    console.warn(`Warning: No smoke-manifest.json found at ${manifestPath}`);
+    console.warn(`Warning: No .oagen-manifest.json found at ${manifestPath}`);
+    console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
+    return null;
+  }
+  const parsed = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+  const operations = parsed?.operations;
+  if (!operations || typeof operations !== 'object') {
+    console.warn('Warning: .oagen-manifest.json has no operations field');
     console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
     return null;
   }
-  const raw = JSON.parse(readFileSync(manifestPath, 'utf-8'));
   const manifest = new Map<string, ManifestEntry>();
-  for (const [httpKey, entry] of Object.entries(raw)) {
+  for (const [httpKey, entry] of Object.entries(operations)) {
     manifest.set(httpKey, entry as ManifestEntry);
   }
   return manifest;

package/smoke/sdk-kotlin.ts

@@ -175,15 +175,21 @@ function createProxyServer(
 // ---------------------------------------------------------------------------
 
 function loadManifest(sdkPath: string): Map<string, ManifestEntry> | null {
-  const manifestPath = resolve(sdkPath, 'smoke-manifest.json');
+  const manifestPath = resolve(sdkPath, '.oagen-manifest.json');
   if (!existsSync(manifestPath)) {
-    console.warn(`Warning: No smoke-manifest.json found at ${manifestPath}`);
-    console.warn('  Method resolution will rely on heuristic tiers — most operations may be skipped.');
+    console.warn(`Warning: No .oagen-manifest.json found at ${manifestPath}`);
+    console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
+    return null;
+  }
+  const parsed = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+  const operations = parsed?.operations;
+  if (!operations || typeof operations !== 'object') {
+    console.warn('Warning: .oagen-manifest.json has no operations field');
+    console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
     return null;
   }
-  const raw = JSON.parse(readFileSync(manifestPath, 'utf-8'));
   const manifest = new Map<string, ManifestEntry>();
-  for (const [httpKey, entry] of Object.entries(raw)) {
+  for (const [httpKey, entry] of Object.entries(operations)) {
     manifest.set(httpKey, entry as ManifestEntry);
   }
   return manifest;

package/smoke/sdk-node.ts

@@ -107,15 +107,21 @@ function restoreFetch(): void {
 // ---------------------------------------------------------------------------
 
 function loadManifest(sdkPath: string): Map<string, ManifestEntry> | null {
-  const manifestPath = resolve(sdkPath, 'smoke-manifest.json');
+  const manifestPath = resolve(sdkPath, '.oagen-manifest.json');
   if (!existsSync(manifestPath)) {
-    console.warn(`⚠ No smoke-manifest.json found at ${manifestPath}`);
-    console.warn('  Method resolution will rely on heuristic tiers — most operations may be skipped.');
+    console.warn(`Warning: No .oagen-manifest.json found at ${manifestPath}`);
+    console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
+    return null;
+  }
+  const parsed = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+  const operations = parsed?.operations;
+  if (!operations || typeof operations !== 'object') {
+    console.warn('Warning: .oagen-manifest.json has no operations field');
+    console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
     return null;
   }
-  const raw = JSON.parse(readFileSync(manifestPath, 'utf-8'));
   const manifest = new Map<string, ManifestEntry>();
-  for (const [httpKey, entry] of Object.entries(raw)) {
+  for (const [httpKey, entry] of Object.entries(operations)) {
     manifest.set(httpKey, entry as ManifestEntry);
   }
   return manifest;

package/smoke/sdk-php.ts

@@ -166,14 +166,19 @@ class CaptureProxy {
 // ---------------------------------------------------------------------------
 
 function loadManifest(sdkPath: string): Map<string, ManifestEntry> | null {
-  const manifestPath = resolve(sdkPath, 'smoke-manifest.json');
+  const manifestPath = resolve(sdkPath, '.oagen-manifest.json');
   if (!existsSync(manifestPath)) {
-    console.warn(`Warning: No smoke-manifest.json found at ${manifestPath}`);
+    console.warn(`Warning: No .oagen-manifest.json found at ${manifestPath}`);
+    return null;
+  }
+  const parsed = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+  const operations = parsed?.operations;
+  if (!operations || typeof operations !== 'object') {
+    console.warn('Warning: .oagen-manifest.json has no operations field');
     return null;
   }
-  const raw = JSON.parse(readFileSync(manifestPath, 'utf-8'));
   const manifest = new Map<string, ManifestEntry>();
-  for (const [httpKey, entry] of Object.entries(raw)) {
+  for (const [httpKey, entry] of Object.entries(operations)) {
     manifest.set(httpKey, entry as ManifestEntry);
   }
   return manifest;

package/smoke/sdk-python.ts

@@ -191,15 +191,21 @@ function createProxyServer(
 // ---------------------------------------------------------------------------
 
 function loadManifest(sdkPath: string): Map<string, ManifestEntry> | null {
-  const manifestPath = resolve(sdkPath, 'smoke-manifest.json');
+  const manifestPath = resolve(sdkPath, '.oagen-manifest.json');
   if (!existsSync(manifestPath)) {
-    console.warn(`Warning: No smoke-manifest.json found at ${manifestPath}`);
+    console.warn(`Warning: No .oagen-manifest.json found at ${manifestPath}`);
+    console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
+    return null;
+  }
+  const parsed = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+  const operations = parsed?.operations;
+  if (!operations || typeof operations !== 'object') {
+    console.warn('Warning: .oagen-manifest.json has no operations field');
     console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
     return null;
   }
-  const raw = JSON.parse(readFileSync(manifestPath, 'utf-8'));
   const manifest = new Map<string, ManifestEntry>();
-  for (const [httpKey, entry] of Object.entries(raw)) {
+  for (const [httpKey, entry] of Object.entries(operations)) {
     manifest.set(httpKey, entry as ManifestEntry);
   }
   return manifest;

package/smoke/sdk-ruby.ts

@@ -78,15 +78,21 @@ interface MethodResolution {
 // ---------------------------------------------------------------------------
 
 function loadManifest(sdkPath: string): Map<string, ManifestEntry> | null {
-  const manifestPath = resolve(sdkPath, 'smoke-manifest.json');
+  const manifestPath = resolve(sdkPath, '.oagen-manifest.json');
   if (!existsSync(manifestPath)) {
-    console.warn(`Warning: No smoke-manifest.json found at ${manifestPath}`);
+    console.warn(`Warning: No .oagen-manifest.json found at ${manifestPath}`);
+    console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
+    return null;
+  }
+  const parsed = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+  const operations = parsed?.operations;
+  if (!operations || typeof operations !== 'object') {
+    console.warn('Warning: .oagen-manifest.json has no operations field');
     console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
     return null;
   }
-  const raw = JSON.parse(readFileSync(manifestPath, 'utf-8'));
   const manifest = new Map<string, ManifestEntry>();
-  for (const [httpKey, entry] of Object.entries(raw)) {
+  for (const [httpKey, entry] of Object.entries(operations)) {
     manifest.set(httpKey, entry as ManifestEntry);
   }
   return manifest;

package/smoke/sdk-rust.ts

@@ -167,15 +167,21 @@ function createProxyServer(
 // ---------------------------------------------------------------------------
 
 function loadManifest(sdkPath: string): Map<string, ManifestEntry> | null {
-  const manifestPath = resolve(sdkPath, 'smoke-manifest.json');
+  const manifestPath = resolve(sdkPath, '.oagen-manifest.json');
   if (!existsSync(manifestPath)) {
-    console.warn(`Warning: No smoke-manifest.json found at ${manifestPath}`);
-    console.warn('  Method resolution will rely on heuristic tiers — most operations may be skipped.');
+    console.warn(`Warning: No .oagen-manifest.json found at ${manifestPath}`);
+    console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
+    return null;
+  }
+  const parsed = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+  const operations = parsed?.operations;
+  if (!operations || typeof operations !== 'object') {
+    console.warn('Warning: .oagen-manifest.json has no operations field');
+    console.warn('  Method resolution will rely on heuristic tiers -- most operations may be skipped.');
     return null;
   }
-  const raw = JSON.parse(readFileSync(manifestPath, 'utf-8'));
   const manifest = new Map<string, ManifestEntry>();
-  for (const [httpKey, entry] of Object.entries(raw)) {
+  for (const [httpKey, entry] of Object.entries(operations)) {
     manifest.set(httpKey, entry as ManifestEntry);
   }
   return manifest;

package/src/dotnet/index.ts

@@ -17,7 +17,7 @@ import { generateEnums, primeEnumAliases } from './enums.js';
 import { generateResources } from './resources.js';
 import { generateClient } from './client.js';
 import { generateTests } from './tests.js';
-import { generateManifest } from './manifest.js';
+import { buildOperationsMap } from './manifest.js';
 import { generateWrapperOptionsClasses } from './wrappers.js';
 import { groupByMount } from '../shared/resolved-ops.js';
 import { discriminatedUnions } from './type-map.js';
@@ -206,8 +206,8 @@ export const dotnetEmitter: Emitter = {
     return prefixTestPaths(ensureTrailingNewlines(generateTests(spec, c)));
   },
 
-  generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
-    return ensureTrailingNewlines(generateManifest(spec, fixNamespace(ctx)));
+  buildOperationsMap(spec: ApiSpec, ctx: EmitterContext) {
+    return buildOperationsMap(spec, fixNamespace(ctx));
   },
 
   fileHeader(): string {

package/src/dotnet/manifest.ts

@@ -1,13 +1,13 @@
-import type { ApiSpec, EmitterContext, GeneratedFile } from '@workos/oagen';
+import type { ApiSpec, EmitterContext, OperationsMap } from '@workos/oagen';
 import { resolveMethodName } from './naming.js';
 import { buildServiceAccessPaths } from './client.js';
 import { getMountTarget } from '../shared/resolved-ops.js';
 
 /**
- * Generate smoke test manifest mapping HTTP operations to SDK methods.
+ * Build operation-to-SDK-method mapping for the manifest.
  */
-export function generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
-  const manifest: Record<string, { sdkMethod: string; service: string }> = {};
+export function buildOperationsMap(spec: ApiSpec, ctx: EmitterContext): OperationsMap {
+  const manifest: OperationsMap = {};
   const accessPaths = buildServiceAccessPaths(spec.services, ctx);
 
   for (const service of spec.services) {
@@ -26,11 +26,5 @@ export function generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedF
     }
   }
 
-  return [
-    {
-      path: 'smoke-manifest.json',
-      content: JSON.stringify(manifest, null, 2),
-      integrateTarget: false,
-    },
-  ];
+  return manifest;
 }

package/src/go/index.ts

@@ -15,7 +15,7 @@ import { generateEnums } from './enums.js';
 import { generateResources } from './resources.js';
 import { generateClient } from './client.js';
 import { generateTests } from './tests.js';
-import { generateManifest } from './manifest.js';
+import { buildOperationsMap } from './manifest.js';
 
 /** Ensure every generated file's content ends with a trailing newline. */
 function ensureTrailingNewlines(files: GeneratedFile[]): GeneratedFile[] {
@@ -33,7 +33,21 @@ export const goEmitter: Emitter = {
   generateModels(models: Model[], ctx: EmitterContext): GeneratedFile[] {
     // Enrich models by flattening oneOf/allOf+oneOf variant fields from the raw spec
     const enriched = enrichModelsFromSpec(models);
-    return ensureTrailingNewlines(generateModels(enriched, ctx));
+    // Go has no sum types, so discriminated union base models (e.g. EventSchema)
+    // need their base fields preserved. enrichModelsFromSpec clears fields for
+    // discriminated models so dispatcher-capable languages can generate sealed
+    // classes; restore the original fields here since Go just emits flat structs.
+    const originalByName = new Map(models.map((m) => [m.name, m]));
+    const goModels = enriched.map((m) => {
+      if ((m as any).discriminator && m.fields.length === 0) {
+        const original = originalByName.get(m.name);
+        if (original && original.fields.length > 0) {
+          return { ...m, fields: original.fields };
+        }
+      }
+      return m;
+    });
+    return ensureTrailingNewlines(generateModels(goModels, ctx));
   },
 
   generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile[] {
@@ -64,8 +78,8 @@ export const goEmitter: Emitter = {
     return ensureTrailingNewlines(generateTests(spec, ctx));
   },
 
-  generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
-    return ensureTrailingNewlines(generateManifest(spec, ctx));
+  buildOperationsMap(spec: ApiSpec, ctx: EmitterContext) {
+    return buildOperationsMap(spec, ctx);
   },
 
   fileHeader(): string {

package/src/go/manifest.ts

@@ -1,13 +1,13 @@
-import type { ApiSpec, EmitterContext, GeneratedFile } from '@workos/oagen';
+import type { ApiSpec, EmitterContext, OperationsMap } from '@workos/oagen';
 import { resolveMethodName } from './naming.js';
 import { buildServiceAccessPaths } from './client.js';
 import { getMountTarget } from '../shared/resolved-ops.js';
 
 /**
- * Generate smoke test manifest mapping HTTP operations to SDK methods.
+ * Build operation-to-SDK-method mapping for the manifest.
  */
-export function generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
-  const manifest: Record<string, { sdkMethod: string; service: string }> = {};
+export function buildOperationsMap(spec: ApiSpec, ctx: EmitterContext): OperationsMap {
+  const manifest: OperationsMap = {};
   const accessPaths = buildServiceAccessPaths(spec.services, ctx);
 
   for (const service of spec.services) {
@@ -26,11 +26,5 @@ export function generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedF
     }
   }
 
-  return [
-    {
-      path: 'smoke-manifest.json',
-      content: JSON.stringify(manifest, null, 2),
-      integrateTarget: false,
-    },
-  ];
+  return manifest;
 }

package/src/kotlin/index.ts

@@ -16,7 +16,7 @@ import { generateEnums } from './enums.js';
 import { generateResources } from './resources.js';
 import { generateClient } from './client.js';
 import { generateTests } from './tests.js';
-import { generateManifest } from './manifest.js';
+import { buildOperationsMap } from './manifest.js';
 import { enrichModelsFromSpec, getSyntheticEnums } from '../shared/model-utils.js';
 
 /** Ensure every generated file ends with a trailing newline. */
@@ -69,8 +69,8 @@ export const kotlinEmitter: Emitter = {
     return ensureTrailingNewlines(generateTests(enrichedSpec, { ...ctx, spec: enrichedSpec }));
   },
 
-  generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
-    return ensureTrailingNewlines(generateManifest(spec, ctx));
+  buildOperationsMap(spec: ApiSpec, ctx: EmitterContext) {
+    return buildOperationsMap(spec, ctx);
   },
 
   fileHeader(): string {

package/src/kotlin/manifest.ts

@@ -1,20 +1,20 @@
-import type { ApiSpec, EmitterContext, GeneratedFile } from '@workos/oagen';
+import type { ApiSpec, EmitterContext, OperationsMap } from '@workos/oagen';
 import { resolveMethodName, servicePropertyName, resolveClassName } from './naming.js';
 import { buildResolvedLookup, lookupResolved, getMountTarget } from '../shared/resolved-ops.js';
 import { propertyName } from './naming.js';
 import { isHandwrittenOverride } from './overrides.js';
 
 /**
- * Generate the smoke-test manifest mapping `"HTTP_METHOD /path"` to
- * `{ sdkMethod, service }`. The `service` is the camelCase accessor property
- * on the main `WorkOS` client (e.g., `organizations`).
+ * Build the operation-to-SDK-method mapping for the manifest.
+ *
+ * The `service` is the camelCase accessor property on the main `WorkOS`
+ * client (e.g., `organizations`).
  *
  * For polymorphic/split operations (e.g., authenticate -> 8 methods), the
- * manifest emits one entry per wrapper method so each variant is addressable.
+ * manifest emits an array of methods so each variant is addressable.
  */
-export function generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
-  const manifest: Record<string, { sdkMethod: string; service: string } | { sdkMethod: string; service: string }[]> =
-    {};
+export function buildOperationsMap(spec: ApiSpec, ctx: EmitterContext): OperationsMap {
+  const manifest: OperationsMap = {};
   const resolvedLookup = buildResolvedLookup(ctx);
 
   for (const service of spec.services) {
@@ -45,11 +45,5 @@ export function generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedF
     }
   }
 
-  return [
-    {
-      path: 'smoke-manifest.json',
-      content: JSON.stringify(manifest, null, 2),
-      integrateTarget: false,
-    },
-  ];
+  return manifest;
 }

package/src/node/index.ts

@@ -18,7 +18,7 @@ import { generateClient } from './client.js';
 import { generateErrors } from './errors.js';
 
 import { generateTests } from './tests.js';
-import { generateManifest } from './manifest.js';
+import { buildOperationsMap } from './manifest.js';
 
 /** Ensure every generated file's content ends with a trailing newline. */
 function ensureTrailingNewlines(files: GeneratedFile[]): GeneratedFile[] {
@@ -62,8 +62,8 @@ export const nodeEmitter: Emitter = {
     return ensureTrailingNewlines(generateTests(spec, ctx));
   },
 
-  generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
-    return ensureTrailingNewlines(generateManifest(spec, ctx));
+  buildOperationsMap(spec: ApiSpec, ctx: EmitterContext) {
+    return buildOperationsMap(spec, ctx);
   },
 
   fileHeader(): string {

package/src/node/manifest.ts

@@ -1,9 +1,9 @@
-import type { ApiSpec, EmitterContext, GeneratedFile } from '@workos/oagen';
+import type { ApiSpec, EmitterContext, OperationsMap } from '@workos/oagen';
 import { resolveMethodName, servicePropertyName } from './naming.js';
 import { resolveResourceClassName } from './resources.js';
 
-export function generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
-  const manifest: Record<string, { sdkMethod: string; service: string }> = {};
+export function buildOperationsMap(spec: ApiSpec, ctx: EmitterContext): OperationsMap {
+  const manifest: OperationsMap = {};
 
   for (const service of spec.services) {
     const propName = servicePropertyName(resolveResourceClassName(service, ctx));
@@ -14,12 +14,5 @@ export function generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedF
     }
   }
 
-  return [
-    {
-      path: 'smoke-manifest.json',
-      content: JSON.stringify(manifest, null, 2),
-      integrateTarget: false,
-      overwriteExisting: true,
-    },
-  ];
+  return manifest;
 }

package/src/php/index.ts

@@ -16,7 +16,7 @@ import { generateEnums } from './enums.js';
 import { generateResources } from './resources.js';
 import { generateClient } from './client.js';
 import { generateTests } from './tests.js';
-import { generateManifest } from './manifest.js';
+import { buildOperationsMap } from './manifest.js';
 import { initializeEnumDedup } from './naming.js';
 
 /** Initialize enum deduplication from spec data. */
@@ -71,9 +71,9 @@ export const phpEmitter: Emitter = {
     return ensureTrailingNewlines(generateTests(spec, ctx));
   },
 
-  generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
+  buildOperationsMap(spec: ApiSpec, ctx: EmitterContext) {
     ensureNamingInitialized(ctx);
-    return ensureTrailingNewlines(generateManifest(spec, ctx));
+    return buildOperationsMap(spec, ctx);
   },
 
   fileHeader(): string {

package/src/php/manifest.ts

@@ -1,13 +1,13 @@
-import type { ApiSpec, EmitterContext, GeneratedFile } from '@workos/oagen';
+import type { ApiSpec, EmitterContext, OperationsMap } from '@workos/oagen';
 import { resolveMethodName } from './naming.js';
 import { buildServiceAccessPaths } from './client.js';
 import { getMountTarget } from '../shared/resolved-ops.js';
 
 /**
- * Generate smoke test manifest mapping HTTP operations to SDK methods.
+ * Build operation-to-SDK-method mapping for the manifest.
  */
-export function generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
-  const manifest: Record<string, { sdkMethod: string; service: string }> = {};
+export function buildOperationsMap(spec: ApiSpec, ctx: EmitterContext): OperationsMap {
+  const manifest: OperationsMap = {};
   const accessPaths = buildServiceAccessPaths(spec.services, ctx);
 
   for (const service of spec.services) {
@@ -26,11 +26,5 @@ export function generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedF
     }
   }
 
-  return [
-    {
-      path: 'smoke-manifest.json',
-      content: JSON.stringify(manifest, null, 2),
-      integrateTarget: false,
-    },
-  ];
+  return manifest;
 }

package/src/php/resources.ts

@@ -261,12 +261,14 @@ function generateMethod(
   }
 
   // @param for body fields
+  const groupedParamNames = collectGroupedParamNames(op);
   if (plan.hasBody && op.requestBody?.kind === 'model') {
     const bodyModel = modelMap.get(op.requestBody.name);
     if (bodyModel) {
       const bodyParamMap = buildBodyParamMap(op, bodyModel);
       for (const field of bodyModel.fields) {
         if (hiddenParams.has(field.name)) continue;
+        if (groupedParamNames.has(field.name)) continue;
         const docType = mapTypeRefForPHPDoc(field.type);
         const phpName = bodyParamMap.get(field.name) ?? fieldName(field.name);
         if (seenDocParams.has(phpName)) continue;
@@ -280,7 +282,6 @@ function generateMethod(
   }
 
   // @param for parameter groups (union-typed)
-  const groupedParamNames = collectGroupedParamNames(op);
   for (const group of op.parameterGroups ?? []) {
     const phpName = fieldName(group.name);
     if (seenDocParams.has(phpName)) continue;
@@ -438,7 +439,9 @@ function generateMethod(
     if (plan.hasBody) {
       const bodyModel = op.requestBody?.kind === 'model' ? modelMap.get(op.requestBody.name) : null;
       const bodyParamMap = buildBodyParamMap(op, bodyModel ?? null);
-      const visibleFields = bodyModel?.fields.filter((f) => !hiddenParams.has(f.name)) ?? [];
+      const deleteGroupedParams = collectGroupedParamNames(op);
+      const visibleFields =
+        bodyModel?.fields.filter((f) => !hiddenParams.has(f.name) && !deleteGroupedParams.has(f.name)) ?? [];
       const hasOptionalFields = visibleFields.some((f) => !f.required);
       if (hasOptionalFields) {
         lines.push('        $body = array_filter([');
@@ -493,7 +496,9 @@ function generateMethod(
   } else if (plan.hasBody) {
     const bodyModel = op.requestBody?.kind === 'model' ? modelMap.get(op.requestBody.name) : null;
     const bodyParamMap = buildBodyParamMap(op, bodyModel ?? null);
-    const visibleFields = bodyModel?.fields.filter((f) => !hiddenParams.has(f.name)) ?? [];
+    const bodyGroupedParams = collectGroupedParamNames(op);
+    const visibleFields =
+      bodyModel?.fields.filter((f) => !hiddenParams.has(f.name) && !bodyGroupedParams.has(f.name)) ?? [];
     const hasOptionalFields = visibleFields.some((f) => !f.required);
     if (hasOptionalFields) {
       lines.push('        $body = array_filter([');
@@ -617,7 +622,6 @@ function buildMethodParams(
   const usedNames = new Set<string>();
   const hidden = hiddenParams ?? new Set();
   const groupedParams = collectGroupedParamNames(op);
-
   // Path params (always required)
   for (const p of op.pathParams) {
     const phpType = mapTypeRef(p.type, { qualified: true });
@@ -633,6 +637,7 @@ function buildMethodParams(
     if (bodyModel) {
       for (const field of bodyModel.fields) {
         if (hidden.has(field.name)) continue;
+        if (groupedParams.has(field.name)) continue;
         const phpType = mapTypeRef(field.type, { qualified: true });
         let phpName = fieldName(field.name);
         if (usedNames.has(phpName)) {