@workos/oagen-emitters 0.4.0 → 0.6.0

package/src/dotnet/tests.ts

@@ -1,17 +1,26 @@
 import type { ApiSpec, Service, Operation, EmitterContext, GeneratedFile } from '@workos/oagen';
 import { planOperation } from '@workos/oagen';
 import {
-  className,
   fixtureFileName,
   fieldName as csFieldName,
   methodName as csMethodName,
+  appendAsyncSuffix,
+  modelClassName,
   resolveMethodName,
+  resolveMethodStem,
   serviceTypeName,
 } from './naming.js';
+import { resolveModelName } from './type-map.js';
 import { resolveResourceClassName, sortPathParamsByTemplateOrder, optionsClassName } from './resources.js';
 import { generateFixtures, generateModelFixture } from './fixtures.js';
 import { isListWrapperModel } from './models.js';
-import { groupByMount, buildResolvedLookup, lookupResolved, buildHiddenParams } from '../shared/resolved-ops.js';
+import {
+  groupByMount,
+  buildResolvedLookup,
+  lookupResolved,
+  buildHiddenParams,
+  collectGroupedParamNames,
+} from '../shared/resolved-ops.js';
 
 /**
  * Generate C# test files and JSON fixtures.
@@ -194,7 +203,7 @@ function generateServiceTest(service: Service, spec: ApiSpec, ctx: EmitterContex
       lines.push(`            this.httpMock.AssertRequestWasMade(HttpMethod.Delete, "${expectedPath}");`);
       lines.push('        }');
     } else if (plan.responseModelName) {
-      const respModel = plan.responseModelName;
+      const respModel = resolveModelName(plan.responseModelName);
       const fixturePath = `testdata/${fixtureFileName(respModel)}.json`;
       const httpMethodCs = op.httpMethod.charAt(0).toUpperCase() + op.httpMethod.slice(1).toLowerCase();
 
@@ -261,8 +270,9 @@ function generateServiceTest(service: Service, spec: ApiSpec, ctx: EmitterContex
     const plan = planOperation(op);
     if (!plan.isPaginated || !op.pagination) continue;
 
-    const method = resolveCsMethodName(op, resolvedName, ctx);
-    const autoPagingTestName = `Test${method}AutoPagingAsync`;
+    const methodStem = resolveCsMethodStem(op, resolvedName, ctx);
+    const autoPagingMethod = `${methodStem}AutoPagingAsync`;
+    const autoPagingTestName = `Test${autoPagingMethod}`;
     if (emittedTestMethods.has(autoPagingTestName)) continue;
     emittedTestMethods.add(autoPagingTestName);
 
@@ -282,8 +292,8 @@ function generateServiceTest(service: Service, spec: ApiSpec, ctx: EmitterContex
             if (inner) resolved = inner;
           }
         }
-        itemTypeName = className(resolved.name);
-        fixtureName = fixtureFileName(resolved.name);
+        itemTypeName = modelClassName(resolveModelName(resolved.name));
+        fixtureName = fixtureFileName(resolveModelName(resolved.name));
       }
     }
 
@@ -310,7 +320,7 @@ function generateServiceTest(service: Service, spec: ApiSpec, ctx: EmitterContex
     );
     lines.push('');
     lines.push(`            var items = new List<${itemTypeName}>();`);
-    lines.push(`            await foreach (var item in this.service.${method}AutoPagingAsync(${autoPagingArgs}))`);
+    lines.push(`            await foreach (var item in this.service.${autoPagingMethod}(${autoPagingArgs}))`);
     lines.push('            {');
     lines.push('                items.Add(item);');
     lines.push('            }');
@@ -319,7 +329,7 @@ function generateServiceTest(service: Service, spec: ApiSpec, ctx: EmitterContex
     lines.push('        }');
 
     // Test with empty first page
-    const emptyTestName = `Test${method}AutoPagingAsyncEmpty`;
+    const emptyTestName = `Test${autoPagingMethod}Empty`;
     if (!emittedTestMethods.has(emptyTestName)) {
       emittedTestMethods.add(emptyTestName);
       lines.push('');
@@ -332,7 +342,7 @@ function generateServiceTest(service: Service, spec: ApiSpec, ctx: EmitterContex
       );
       lines.push('');
       lines.push(`            var items = new List<${itemTypeName}>();`);
-      lines.push(`            await foreach (var item in this.service.${method}AutoPagingAsync(${autoPagingArgs}))`);
+      lines.push(`            await foreach (var item in this.service.${autoPagingMethod}(${autoPagingArgs}))`);
       lines.push('            {');
       lines.push('                items.Add(item);');
       lines.push('            }');
@@ -348,7 +358,8 @@ function generateServiceTest(service: Service, spec: ApiSpec, ctx: EmitterContex
     if (!resolvedOp?.wrappers || resolvedOp.wrappers.length === 0) continue;
 
     for (const wrapper of resolvedOp.wrappers) {
-      const wrapperMethod = csMethodName(wrapper.name);
+      const wrapperMethodStem = csMethodName(wrapper.name);
+      const wrapperMethod = appendAsyncSuffix(wrapperMethodStem);
       const wrapperTestName = `Test${wrapperMethod}`;
       if (emittedTestMethods.has(wrapperTestName)) continue;
       emittedTestMethods.add(wrapperTestName);
@@ -363,7 +374,7 @@ function generateServiceTest(service: Service, spec: ApiSpec, ctx: EmitterContex
       lines.push('        {');
 
       if (responseType) {
-        const fixturePath = `testdata/${fixtureFileName(responseType)}.json`;
+        const fixturePath = `testdata/${fixtureFileName(resolveModelName(responseType))}.json`;
         lines.push(`            var fixture = System.IO.File.ReadAllText("${fixturePath}");`);
         lines.push(
           `            this.httpMock.MockResponse(HttpMethod.${httpMethodCs}, "${expectedPath}", HttpStatusCode.OK, fixture);`,
@@ -379,7 +390,7 @@ function generateServiceTest(service: Service, spec: ApiSpec, ctx: EmitterContex
       for (const p of sortPathParamsByTemplateOrder(op)) {
         wrapperArgs.push(`"test_${p.name}"`);
       }
-      wrapperArgs.push(`new ${wrapperMethod}Options()`);
+      wrapperArgs.push(`new ${wrapperMethodStem}Options()`);
 
       if (responseType) {
         lines.push(`            var result = await this.service.${wrapperMethod}(${wrapperArgs.join(', ')});`);
@@ -411,11 +422,11 @@ function generateServiceTest(service: Service, spec: ApiSpec, ctx: EmitterContex
     );
     if (plan.isPaginated || plan.isDelete || !plan.responseModelName) {
       lines.push(
-        `            await Assert.ThrowsAsync<AuthenticationError>(() => this.service.${method}(${callArgs}));`,
+        `            await Assert.ThrowsAsync<AuthenticationException>(() => this.service.${method}(${callArgs}));`,
       );
     } else {
       lines.push(
-        `            await Assert.ThrowsAsync<AuthenticationError>(() => this.service.${method}(${callArgs}));`,
+        `            await Assert.ThrowsAsync<AuthenticationException>(() => this.service.${method}(${callArgs}));`,
       );
     }
     lines.push('        }');
@@ -428,7 +439,7 @@ function generateServiceTest(service: Service, spec: ApiSpec, ctx: EmitterContex
     lines.push(
       `            this.httpMock.MockResponseForAnyRequest(HttpStatusCode.NotFound, "{\\"code\\":\\"not_found\\",\\"message\\":\\"Not Found\\"}");`,
     );
-    lines.push(`            await Assert.ThrowsAsync<NotFoundError>(() => this.service.${method}(${callArgs}));`);
+    lines.push(`            await Assert.ThrowsAsync<NotFoundException>(() => this.service.${method}(${callArgs}));`);
     lines.push('        }');
 
     // 422
@@ -440,7 +451,7 @@ function generateServiceTest(service: Service, spec: ApiSpec, ctx: EmitterContex
       `            this.httpMock.MockResponseForAnyRequest((HttpStatusCode)422, "{\\"code\\":\\"unprocessable_entity\\",\\"message\\":\\"Unprocessable\\"}");`,
     );
     lines.push(
-      `            await Assert.ThrowsAsync<UnprocessableEntityError>(() => this.service.${method}(${callArgs}));`,
+      `            await Assert.ThrowsAsync<UnprocessableEntityException>(() => this.service.${method}(${callArgs}));`,
     );
     lines.push('        }');
 
@@ -453,7 +464,7 @@ function generateServiceTest(service: Service, spec: ApiSpec, ctx: EmitterContex
       `            this.httpMock.MockResponseForAnyRequest((HttpStatusCode)429, "{\\"code\\":\\"too_many_requests\\",\\"message\\":\\"Too Many Requests\\"}");`,
     );
     lines.push(
-      `            await Assert.ThrowsAsync<RateLimitExceededError>(() => this.service.${method}(${callArgs}));`,
+      `            await Assert.ThrowsAsync<RateLimitExceededException>(() => this.service.${method}(${callArgs}));`,
     );
     lines.push('        }');
 
@@ -465,7 +476,7 @@ function generateServiceTest(service: Service, spec: ApiSpec, ctx: EmitterContex
     lines.push(
       `            this.httpMock.MockResponseForAnyRequest(HttpStatusCode.InternalServerError, "{\\"code\\":\\"server_error\\",\\"message\\":\\"Server Error\\"}");`,
     );
-    lines.push(`            await Assert.ThrowsAsync<ServerError>(() => this.service.${method}(${callArgs}));`);
+    lines.push(`            await Assert.ThrowsAsync<ServerException>(() => this.service.${method}(${callArgs}));`);
     lines.push('        }');
   }
 
@@ -483,6 +494,10 @@ function resolveCsMethodName(op: Operation, mountName: string, ctx: EmitterConte
   return resolveMethodName(op, { name: mountName, operations: [op] }, ctx);
 }
 
+function resolveCsMethodStem(op: Operation, mountName: string, ctx: EmitterContext): string {
+  return resolveMethodStem(op, { name: mountName, operations: [op] }, ctx);
+}
+
 function buildMethodCallArgs(op: Operation, plan: any, ctx: EmitterContext, mountName: string): string {
   const args: string[] = [];
 
@@ -502,7 +517,10 @@ function buildMethodCallArgs(op: Operation, plan: any, ctx: EmitterContext, moun
   const resolvedLookup = buildResolvedLookup(ctx);
   const resolvedOp = lookupResolved(op, resolvedLookup);
   const hidden = buildHiddenParams(resolvedOp);
-  const hasVisibleQueryParams = op.queryParams.filter((qp) => !hidden.has(qp.name)).length > 0;
+  const groupedParams = collectGroupedParamNames(op);
+  const hasVisibleQueryParams =
+    op.queryParams.filter((qp) => !hidden.has(qp.name) && !groupedParams.has(qp.name)).length > 0 ||
+    (op.parameterGroups?.length ?? 0) > 0;
   const hasBody = plan.hasBody && op.requestBody;
   let hasVisibleBodyFields = false;
   if (hasBody && op.requestBody?.kind === 'model') {
@@ -513,8 +531,8 @@ function buildMethodCallArgs(op: Operation, plan: any, ctx: EmitterContext, moun
   }
 
   if (hasVisibleBodyFields || hasVisibleQueryParams) {
-    const method = resolveCsMethodName(op, mountName, ctx);
-    const optName = optionsClassName(mountName, method);
+    const methodStem = resolveCsMethodStem(op, mountName, ctx);
+    const optName = optionsClassName(mountName, methodStem);
     args.push(`new ${optName}()`);
   }
 
@@ -566,8 +584,10 @@ function buildRequestShapeSeed(op: Operation, plan: any, ctx: EmitterContext, mo
   // call sends it via the body — so skip the query assertion to avoid a
   // false-failing `AssertQueryParam`.
   const bodyWireNames = new Set(bodySeeds.map((s) => s.wire));
+  const groupedParamNames = collectGroupedParamNames(op);
   for (const param of op.queryParams) {
     if (hidden.has(param.name)) continue;
+    if (groupedParamNames.has(param.name)) continue;
     if (!param.required) continue;
     if (!isSeedableStringRef(param.type)) continue;
     // Skip pagination fields — they're set by the caller or the autopaging loop
@@ -585,8 +605,8 @@ function buildRequestShapeSeed(op: Operation, plan: any, ctx: EmitterContext, mo
     return { setupLines: [], seededCallArgs: null, assertLines: [] };
   }
 
-  const method = resolveCsMethodName(op, mountName, ctx);
-  const optName = optionsClassName(mountName, method);
+  const methodStem = resolveCsMethodStem(op, mountName, ctx);
+  const optName = optionsClassName(mountName, methodStem);
 
   // Rebuild call args with a seeded options variable named `options`.
   const args: string[] = [];

package/src/dotnet/type-map.ts

@@ -1,6 +1,6 @@
 import type { TypeRef, PrimitiveType, UnionType } from '@workos/oagen';
 import { mapTypeRef as irMapTypeRef } from '@workos/oagen';
-import { className } from './naming.js';
+import { className, modelClassName } from './naming.js';
 
 /** Known C# value types that need `?` for nullable. */
 const VALUE_TYPES = new Set(['int', 'long', 'double', 'bool', 'float', 'decimal', 'byte', 'short', 'DateTimeOffset']);
@@ -21,12 +21,35 @@ const enumAliases = new Map<string, string>();
  */
 const singleValueEnumNames = new Set<string>();
 
+/**
+ * Module-level alias map for structurally-identical models. Populated by
+ * `setModelAliases` from model deduplication; consulted by `mapTypeRef` so
+ * that every reference to a duplicate model resolves to the canonical name.
+ */
+const modelAliases = new Map<string, string>();
+
 /** Replace the current enum-alias map. Safe to call more than once. */
 export function setEnumAliases(aliases: Map<string, string>): void {
   enumAliases.clear();
   for (const [k, v] of aliases) enumAliases.set(k, v);
 }
 
+/** Replace the current model-alias map. Safe to call more than once. */
+export function setModelAliases(aliases: Map<string, string>): void {
+  modelAliases.clear();
+  for (const [k, v] of aliases) modelAliases.set(k, v);
+}
+
+/** Check if a model name is an alias (i.e., structurally identical to another model). */
+export function isModelAlias(name: string): boolean {
+  return modelAliases.has(name);
+}
+
+/** Resolve a model name to its canonical form (identity if not an alias). */
+export function resolveModelName(name: string): string {
+  return modelAliases.get(name) ?? name;
+}
+
 /** Replace the set of enum names that are single-value discriminator stand-ins. */
 export function setSingleValueEnumNames(names: Iterable<string>): void {
   singleValueEnumNames.clear();
@@ -45,7 +68,7 @@ export function mapTypeRef(ref: TypeRef): string {
   return irMapTypeRef<string>(ref, {
     primitive: mapPrimitive,
     array: (_ref, items) => `List<${items}>`,
-    model: (r) => className(r.name),
+    model: (r) => modelClassName(modelAliases.get(r.name) ?? r.name),
     enum: (r) => {
       // Single-value enums (discriminator consts in disguise) map to `string`
       // so the caller can't misuse a public one-member enum type. The
@@ -123,21 +146,25 @@ export function isEnumRef(ref: TypeRef): boolean {
 }
 
 /**
- * Emit JSON attributes for a request-side property. When `isRequiredEnum` is
- * true, configure both serializers to skip the field when its value equals the
- * enum default (0 = Unknown sentinel). This converts "unset required enum"
- * from a silent `"unknown"` wire value into a clean omission so the API
- * returns a clear `missing required field` error instead of a confusing 422.
+ * Emit JSON attributes for a request-side property. Property name mapping is
+ * handled by a global SnakeCaseLower / SnakeCaseNamingStrategy configuration
+ * on both serializers, so per-property name attributes are not emitted.
+ *
+ * When `isRequiredEnum` is true, configure both serializers to skip the field
+ * when its value equals the enum default (0 = Unknown sentinel). This converts
+ * "unset required enum" from a silent `"unknown"` wire value into a clean
+ * omission so the API returns a clear `missing required field` error instead
+ * of a confusing 422.
  */
-export function emitJsonPropertyAttributes(wireName: string, options: { isRequiredEnum?: boolean } = {}): string[] {
+export function emitJsonPropertyAttributes(_wireName: string, options: { isRequiredEnum?: boolean } = {}): string[] {
   if (options.isRequiredEnum) {
     return [
-      `        [JsonProperty("${wireName}", DefaultValueHandling = DefaultValueHandling.Ignore)]`,
-      `        [STJS.JsonPropertyName("${wireName}")]`,
+      `        [JsonProperty(DefaultValueHandling = DefaultValueHandling.Ignore)]`,
       `        [STJS.JsonIgnore(Condition = STJS.JsonIgnoreCondition.WhenWritingDefault)]`,
     ];
   }
-  return [`        [JsonProperty("${wireName}")]`, `        [STJS.JsonPropertyName("${wireName}")]`];
+  // Convention-based: SnakeCaseLower naming policy handles the name mapping.
+  return [];
 }
 
 function mapPrimitive(ref: PrimitiveType): string {
@@ -188,13 +215,13 @@ function joinUnionVariants(_ref: UnionType, variants: string[]): string {
     return 'object';
   }
 
-  if (unique.length >= 2 && unique.length <= 3) return `AnyOf<${unique.join(', ')}>`;
-  // AnyOf only supports arity 2 and 3. Higher-arity unions collapse to
-  // `object`, losing type information. Warn so the author knows the spec
-  // outgrew the runtime support instead of silently degrading.
-  if (unique.length >= 4) {
+  if (unique.length >= 2 && unique.length <= 9) return `OneOf.OneOf<${unique.join(', ')}>`;
+  // OneOf supports arity 2-9. Higher-arity unions collapse to `object`,
+  // losing type information. Warn so the author knows the spec outgrew the
+  // runtime support instead of silently degrading.
+  if (unique.length >= 10) {
     console.warn(
-      `[oagen:dotnet] Union with ${unique.length} variants exceeds AnyOf<T1,T2,T3> arity; falling back to object. Variants: ${unique.join(', ')}`,
+      `[oagen:dotnet] Union with ${unique.length} variants exceeds OneOf<T0..T8> arity; falling back to object. Variants: ${unique.join(', ')}`,
     );
   }
   return 'object';

package/src/dotnet/wrappers.ts

@@ -1,6 +1,5 @@
 import type { EmitterContext, ResolvedOperation, ResolvedWrapper } from '@workos/oagen';
 import {
-  className as csClassName,
   fieldName as csFieldName,
   methodName as csMethodName,
   localName,
@@ -10,6 +9,8 @@ import {
   escapeXml,
   emitXmlDoc,
   humanize,
+  appendAsyncSuffix,
+  modelClassName,
 } from './naming.js';
 import { sortPathParamsByTemplateOrder } from './resources.js';
 import { resolveWrapperParams, formatWrapperDescription, type ResolvedWrapperParam } from '../shared/wrapper-utils.js';
@@ -44,9 +45,10 @@ function emitWrapperMethod(
   _ctx: EmitterContext,
 ): void {
   const op = resolvedOp.operation;
-  const method = csMethodName(wrapper.name);
-  const optionsClass = `${method}Options`;
-  const responseType = wrapper.responseModelName ? csClassName(wrapper.responseModelName) : null;
+  const methodStem = csMethodName(wrapper.name);
+  const method = appendAsyncSuffix(methodStem);
+  const optionsClass = `${methodStem}Options`;
+  const responseType = wrapper.responseModelName ? modelClassName(wrapper.responseModelName) : null;
 
   // XML doc
   lines.push(`        /// <summary>${formatWrapperDescription(wrapper.name)}.</summary>`);
@@ -63,12 +65,18 @@ function emitWrapperMethod(
 
   // Signature
   const sigParams: string[] = [];
+  const argNames: string[] = [];
   for (const p of sortPathParamsByTemplateOrder(op)) {
-    sigParams.push(`string ${localName(p.name)}`);
+    const name = localName(p.name);
+    sigParams.push(`string ${name}`);
+    argNames.push(name);
   }
   sigParams.push(`${optionsClass} options`);
+  argNames.push('options');
   sigParams.push('RequestOptions? requestOptions = null');
+  argNames.push('requestOptions');
   sigParams.push('CancellationToken cancellationToken = default');
+  argNames.push('cancellationToken');
 
   const returnType = responseType ? `Task<${responseType}>` : 'Task';
   lines.push(`        public async ${returnType} ${method}(${sigParams.join(', ')})`);
@@ -96,7 +104,7 @@ function emitWrapperMethod(
   if (op.pathParams.length > 0) {
     let interpolated = op.path;
     for (const p of sortPathParamsByTemplateOrder(op)) {
-      interpolated = interpolated.replace(`{${p.name}}`, `{${localName(p.name)}}`);
+      interpolated = interpolated.replace(`{${p.name}}`, `{Uri.EscapeDataString(${localName(p.name)})}`);
     }
     pathExpr = `$"${interpolated}"`;
   } else {
@@ -116,6 +124,13 @@ function emitWrapperMethod(
   }
 
   lines.push('        }');
+
+  lines.push('');
+  lines.push(`        /// <summary>Compatibility wrapper for <see cref="${method}"/>.</summary>`);
+  lines.push(`        public Task${responseType ? `<${responseType}>` : ''} ${methodStem}(${sigParams.join(', ')})`);
+  lines.push('        {');
+  lines.push(`            return this.${method}(${argNames.join(', ')});`);
+  lines.push('        }');
 }
 
 // NOTE: T26 (wrapper DRY) — the AuthenticateWith* wrappers share a small
@@ -158,8 +173,6 @@ export function generateWrapperOptionsClasses(resolvedOp: ResolvedOperation, ctx
     // Hidden fields (defaults + inferred)
     for (const key of Object.keys(wrapper.defaults)) {
       const csField = csFieldName(key);
-      lines.push(`        [JsonProperty("${key}")]`);
-      lines.push(`        [STJS.JsonPropertyName("${key}")]`);
       lines.push(`        internal string ${csField} { get; set; } = default!;`);
       lines.push('');
     }
@@ -167,8 +180,6 @@ export function generateWrapperOptionsClasses(resolvedOp: ResolvedOperation, ctx
       const csField = csFieldName(key);
       // Skip if already added as a default
       if (Object.keys(wrapper.defaults).includes(key)) continue;
-      lines.push(`        [JsonProperty("${key}")]`);
-      lines.push(`        [STJS.JsonPropertyName("${key}")]`);
       lines.push(`        internal string ${csField} { get; set; } = default!;`);
       lines.push('');
     }

package/src/go/client.ts

@@ -2,8 +2,9 @@ import type { ApiSpec, EmitterContext, GeneratedFile, Service } from '@workos/oa
 import { toPascalCase, toSnakeCase } from '@workos/oagen';
 // naming utilities used indirectly via resolveResourceClassName
 import { resolveResourceClassName } from './resources.js';
-import { unexportedName } from './naming.js';
+import { className, unexportedName } from './naming.js';
 import { getMountTarget } from '../shared/resolved-ops.js';
+import { NON_SPEC_SERVICES } from '../shared/non-spec-services.js';
 
 /**
  * Generate the Go client file with service accessors.
@@ -15,6 +16,16 @@ export function generateClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFil
   return [generateWorkOSFile(spec, ctx)];
 }
 
+/**
+ * Non-spec services marked with `hasClientAccessor: true` (passwordless, vault)
+ * are included in the generated Client struct, constructor, and accessor methods
+ * — identical to spec-driven services. Their service type (e.g. PasswordlessService)
+ * is defined in a hand-written @oagen-ignore-file, but the Client wiring is generated.
+ *
+ * Other non-spec modules (webhook_verification, actions, etc.) remain fully
+ * self-contained in their @oagen-ignore-file files.
+ */
+
 /**
  * Deduplicate services by mount target.
  */
@@ -72,6 +83,8 @@ function generateWorkOSFile(spec: ApiSpec, ctx: EmitterContext): GeneratedFile {
   lines.push('\tbaseURL      string');
   lines.push('\thttpClient   *http.Client');
   lines.push('\tmaxRetries   int');
+  lines.push('\tlogger       Logger');
+  lines.push('\tappInfo      appInfo');
   lines.push('');
   // Service fields
   for (const service of topLevel) {
@@ -80,6 +93,11 @@ function generateWorkOSFile(spec: ApiSpec, ctx: EmitterContext): GeneratedFile {
     const serviceTypeName = serviceType(resolvedName);
     lines.push(`\t${fieldNameStr} *${serviceTypeName}`);
   }
+  // Non-spec service fields (hand-written types, generated wiring)
+  for (const ns of NON_SPEC_SERVICES.filter((s) => s.hasClientAccessor)) {
+    const name = className(toPascalCase(ns.id));
+    lines.push(`\t${unexportedName(name)} *${serviceType(name)}`);
+  }
   lines.push('}');
   lines.push('');
 
@@ -102,6 +120,11 @@ function generateWorkOSFile(spec: ApiSpec, ctx: EmitterContext): GeneratedFile {
     const serviceTypeName = serviceType(resolvedName);
     lines.push(`\tc.${fieldNameStr} = &${serviceTypeName}{client: c}`);
   }
+  // Initialize non-spec services
+  for (const ns of NON_SPEC_SERVICES.filter((s) => s.hasClientAccessor)) {
+    const name = className(toPascalCase(ns.id));
+    lines.push(`\tc.${unexportedName(name)} = &${serviceType(name)}{client: c}`);
+  }
   lines.push('\treturn c');
   lines.push('}');
   lines.push('');
@@ -118,7 +141,16 @@ function generateWorkOSFile(spec: ApiSpec, ctx: EmitterContext): GeneratedFile {
     lines.push('}');
     lines.push('');
   }
-
+  // Non-spec service accessor methods
+  for (const ns of NON_SPEC_SERVICES.filter((s) => s.hasClientAccessor)) {
+    const name = className(toPascalCase(ns.id));
+    const typeName = serviceType(name);
+    lines.push(`// ${name} returns the ${name} service.`);
+    lines.push(`func (c *Client) ${name}() *${typeName} {`);
+    lines.push(`\treturn c.${unexportedName(name)}`);
+    lines.push('}');
+    lines.push('');
+  }
   return {
     path: `${ctx.namespace}.go`,
     content: lines.join('\n'),
@@ -137,5 +169,5 @@ function singularizePascal(name: string): string {
 }
 
 function serviceType(name: string): string {
-  return `${unexportedName(singularizePascal(name))}Service`;
+  return `${className(singularizePascal(name))}Service`;
 }

package/src/go/enums.ts

@@ -29,6 +29,10 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
     if (canonicalName) {
       const aliasType = className(enumDef.name);
       const canonicalType = className(canonicalName);
+      // Skip when different IR names map to the same Go type (e.g. synthetic
+      // enums from enrichModelsFromSpec whose underscore names collapse to the
+      // same PascalCase as the original enum).
+      if (aliasType === canonicalType) continue;
       lines.push(`// ${aliasType} is an alias for ${canonicalType}.`);
       lines.push(`type ${aliasType} = ${canonicalType}`);
       lines.push('');

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[] {
@@ -64,20 +64,25 @@ 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 {
     return '// Code generated by oagen. DO NOT EDIT.';
   },
 
-  formatCommand(targetDir: string): FormatCommand | null {
-    // Pass targetDir as the first path so gofmt formats the entire directory
-    // (including hand-maintained files), not just the generated file list.
+  formatCommand(_targetDir: string): FormatCommand | null {
+    // oagen appends all generated file paths (including .json fixtures) to the
+    // format command. gofmt errors on non-.go files, so filter them out.
+    // Same pattern as the Python emitter's ruff wrapper.
     return {
-      cmd: 'gofmt',
-      args: ['-w', targetDir],
+      cmd: 'bash',
+      args: [
+        '-c',
+        'GO_FILES=$(printf "%s\\n" "$@" | grep "\\.go$"); [ -n "$GO_FILES" ] && echo "$GO_FILES" | xargs gofmt -w',
+        '--',
+      ],
       batchSize: 999999,
     };
   },

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/go/models.ts

@@ -59,9 +59,14 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
       if (batchedAliases.has(model.name)) continue;
 
       const canonicalStruct = className(canonicalName);
+      // Skip when different IR names map to the same Go type (e.g. synthetic
+      // models from enrichModelsFromSpec whose underscore names collapse to the
+      // same PascalCase as the original model).
+      if (structName === canonicalStruct) continue;
+
       const hash = modelHashMap.get(model.name)!;
       const groupNames = hashGroups.get(hash) ?? [];
-      const aliases = groupNames.filter((n) => aliasOf.has(n));
+      const aliases = groupNames.filter((n) => aliasOf.has(n) && className(n) !== className(aliasOf.get(n)!));
 
       if (aliases.length >= 5) {
         // Batch emit all aliases for this group at once