@workos/oagen-emitters 0.18.3 → 0.19.0

package/src/php/resources.ts

@@ -12,7 +12,7 @@ import { mapTypeRef, mapTypeRefForPHPDoc } from './type-map.js';
 import { className, fieldName, resolveMethodName, buildExportedClassNameSet, resolveServiceTarget } from './naming.js';
 import { isListWrapperModel } from './models.js';
 import {
-  groupByMount,
+  scopedMountGroups,
   buildResolvedLookup,
   lookupResolved,
   getOpDefaults,
@@ -44,10 +44,12 @@ export function generateResources(services: Service[], ctx: EmitterContext): Gen
   const files: GeneratedFile[] = [];
   const modelMap = new Map(ctx.spec.models.map((m) => [m.name, m]));
 
-  // Group operations by mount target
-  const mountGroups = groupByMount(ctx);
+  // Group operations by mount target. In a scoped (`--services`) run this
+  // returns only the selected post-mount services so we emit per-service
+  // resource files for those alone.
+  const mountGroups = scopedMountGroups(ctx);
   const entries: Array<{ name: string; operations: Operation[] }> =
-    mountGroups.size > 0
+    mountGroups.size > 0 || ctx.scopedServices?.size
       ? [...mountGroups].map(([name, group]) => ({ name, operations: group.operations }))
       : services.map((s) => ({ name: className(s.name), operations: s.operations }));
 

package/src/php/tests.ts

@@ -8,12 +8,19 @@ import type {
   ResolvedOperation,
 } from '@workos/oagen';
 import { planOperation, toCamelCase, toPascalCase } from '@workos/oagen';
-import { className, enumClassName, resolveMethodName, snakeName, servicePropertyName } from './naming.js';
+import {
+  className,
+  enumClassName,
+  resolveMethodName,
+  snakeName,
+  servicePropertyName,
+  domainFieldName,
+} from './naming.js';
 import { isListWrapperModel } from './models.js';
 import { generateFixtures } from './fixtures.js';
 import {
   getMountTarget,
-  groupByMount,
+  scopedMountGroups,
   buildHiddenParams,
   getOpDefaults,
   getOpInferFromClient,
@@ -32,9 +39,12 @@ export function generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
 
   // Collect all operations per mount target using resolved per-operation mounts.
   // This correctly handles operationHint mountOn overrides (e.g., audit_logs_retention → AuditLogs).
-  const mountGroupsFromResolved = groupByMount(ctx);
+  // In a scoped (`--services`) run this returns only the selected post-mount
+  // services so we emit per-service test files for those alone. ClientTest.php
+  // and fixtures below are built from `spec` and stay full.
+  const mountGroupsFromResolved = scopedMountGroups(ctx);
   const mountGroups = new Map<string, { op: Operation; service: Service; resolvedOp?: ResolvedOperation }[]>();
-  if (mountGroupsFromResolved.size > 0) {
+  if (mountGroupsFromResolved.size > 0 || ctx.scopedServices?.size) {
     for (const [target, group] of mountGroupsFromResolved) {
       mountGroups.set(
         target,
@@ -503,7 +513,9 @@ function emitFieldHydrationAssertions(
 
   for (const f of assertFields) {
     if (!f) continue;
-    const phpProp = toCamelCase(f.name);
+    // DOMAIN identifier: the deserialized model's PHP property (honors `domainName`).
+    // The fixture key `f.name` is the WIRE key and stays unchanged.
+    const phpProp = domainFieldName(f);
     lines.push(`        $this->assertSame(${fixtureVar}['${f.name}'], ${resultVar}->${phpProp});`);
   }
 }

package/src/python/enums.ts

@@ -2,6 +2,7 @@ import type { Enum, EmitterContext, GeneratedFile } from '@workos/oagen';
 import { toUpperSnakeCase } from '@workos/oagen';
 import { className, fileName, buildMountDirMap, dirToModule } from './naming.js';
 import { computeSchemaPlacement } from './shared-schemas.js';
+import { isEnumInScope } from '../shared/resolved-ops.js';
 
 /**
  * Convert a PascalCase class name to a human-readable lowercase string,
@@ -38,6 +39,10 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
   for (const enumDef of enums) {
     const service = enumToService.get(enumDef.name);
     const dirName = resolveDir(service);
+    // FR-1.4: write per-enum FILES only when in scope; the enum barrel is built
+    // separately (collectGeneratedEnumSymbolsByDir over the full set), so an
+    // out-of-scope enum left on disk stays exported and importable.
+    const enumInScope = isEnumInScope(enumDef.name, ctx);
 
     // If this enum is an alias for a canonical enum, generate a type alias file
     const canonicalName = aliasOf.get(enumDef.name);
@@ -73,12 +78,14 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
         lines.push('        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")');
       }
       lines.push(`__all__ = ["${aliasCls}"]`);
-      files.push({
-        path: `src/${ctx.namespace}/${dirName}/models/${fileName(enumDef.name)}.py`,
-        content: lines.join('\n'),
-        integrateTarget: true,
-        overwriteExisting: true,
-      });
+      if (enumInScope) {
+        files.push({
+          path: `src/${ctx.namespace}/${dirName}/models/${fileName(enumDef.name)}.py`,
+          content: lines.join('\n'),
+          integrateTarget: true,
+          overwriteExisting: true,
+        });
+      }
 
       // Also generate compat alias files for dedup aliases (they may have compat aliases too)
       for (const aliasName of compatAliases.get(enumDef.name) ?? []) {
@@ -107,12 +114,14 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
             `__all__ = ["${aliasName}"]`,
           ].join('\n');
         }
-        files.push({
-          path: `src/${ctx.namespace}/${dirName}/models/${fileName(aliasName)}.py`,
-          content: compatContent,
-          integrateTarget: true,
-          overwriteExisting: true,
-        });
+        if (enumInScope) {
+          files.push({
+            path: `src/${ctx.namespace}/${dirName}/models/${fileName(aliasName)}.py`,
+            content: compatContent,
+            integrateTarget: true,
+            overwriteExisting: true,
+          });
+        }
       }
 
       continue;
@@ -241,26 +250,28 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
       );
     }
 
-    files.push({
-      path: `src/${ctx.namespace}/${dirName}/models/${fileName(enumDef.name)}.py`,
-      content: lines.join('\n'),
-      integrateTarget: true,
-      overwriteExisting: true,
-    });
-
-    for (const aliasName of compatAliases.get(enumDef.name) ?? []) {
+    if (enumInScope) {
       files.push({
-        path: `src/${ctx.namespace}/${dirName}/models/${fileName(aliasName)}.py`,
-        content: [
-          'from typing import TypeAlias',
-          `from .${fileName(enumDef.name)} import ${cls}`,
-          '',
-          `${aliasName}: TypeAlias = ${cls}`,
-          `__all__ = ["${aliasName}"]`,
-        ].join('\n'),
+        path: `src/${ctx.namespace}/${dirName}/models/${fileName(enumDef.name)}.py`,
+        content: lines.join('\n'),
         integrateTarget: true,
         overwriteExisting: true,
       });
+
+      for (const aliasName of compatAliases.get(enumDef.name) ?? []) {
+        files.push({
+          path: `src/${ctx.namespace}/${dirName}/models/${fileName(aliasName)}.py`,
+          content: [
+            'from typing import TypeAlias',
+            `from .${fileName(enumDef.name)} import ${cls}`,
+            '',
+            `${aliasName}: TypeAlias = ${cls}`,
+            `__all__ = ["${aliasName}"]`,
+          ].join('\n'),
+          integrateTarget: true,
+          overwriteExisting: true,
+        });
+      }
     }
   }
 

package/src/python/fixtures.ts

@@ -1,6 +1,6 @@
 import type { Model, TypeRef, Enum } from '@workos/oagen';
 
-import { fileName, fieldName } from './naming.js';
+import { fileName, domainFieldName } from './naming.js';
 import { isListMetadataModel, isListWrapperModel } from './models.js';
 import { collectNonPaginatedResponseModelNames, collectReferencedListMetadataModels } from '../shared/model-utils.js';
 
@@ -104,10 +104,11 @@ export function generateModelFixture(
 ): Record<string, any> {
   const fixture: Record<string, any> = {};
 
-  // Deduplicate fields by snake_case name (matching model generation in models.ts)
+  // Deduplicate fields by DOMAIN identifier (matching model generation in
+  // models.ts, which honors `domainName`); the wire key below stays `field.name`.
   const seenFieldNames = new Set<string>();
   const deduplicatedFields = model.fields.filter((f) => {
-    const pyName = fieldName(f.name);
+    const pyName = domainFieldName(f);
     if (seenFieldNames.has(pyName)) return false;
     seenFieldNames.add(pyName);
     return true;

package/src/python/index.ts

@@ -11,6 +11,7 @@ import type {
 
 import { generateModels } from './models.js';
 import { detectDiscriminators } from '../shared/model-utils.js';
+import { AUTOGEN_NOTICE } from '../shared/file-header.js';
 import { generateEnums } from './enums.js';
 import { generateResources } from './resources.js';
 import { generateClient } from './client.js';
@@ -86,7 +87,7 @@ export const pythonEmitter: Emitter = {
   },
 
   fileHeader(): string {
-    return '# This file is auto-generated by oagen. Do not edit.';
+    return `# ${AUTOGEN_NOTICE}`;
   },
 
   formatCommand(_targetDir: string): FormatCommand | null {

package/src/python/models.ts

@@ -1,9 +1,10 @@
 import type { Model, EmitterContext, GeneratedFile } from '@workos/oagen';
 import { collectFieldDependencies, walkTypeRef } from '@workos/oagen';
 import { mapTypeRef } from './type-map.js';
-import { className, fieldName, fileName, buildMountDirMap, dirToModule } from './naming.js';
+import { className, domainFieldName, fileName, buildMountDirMap, dirToModule } from './naming.js';
 import { collectGeneratedEnumSymbolsByDir } from './enums.js';
 import { computeSchemaPlacement } from './shared-schemas.js';
+import { isModelInScope } from '../shared/resolved-ops.js';
 
 /**
  * Generate Python dataclass model files from IR Model definitions.
@@ -169,12 +170,16 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
       dispLines.push(`            return cast("${variantTypeName}", dispatch_cls.from_dict(data))`);
       dispLines.push(`        return ${unknownClassName}.from_dict(data)`);
 
-      files.push({
-        path: `src/${ctx.namespace}/${dirName}/models/${fileName(model.name)}.py`,
-        content: dispLines.join('\n'),
-        integrateTarget: true,
-        overwriteExisting: true,
-      });
+      // FR-1.4: write the file only when in scope; the barrel tracking below is
+      // unconditional so out-of-scope models (left on disk) stay exported.
+      if (isModelInScope(model.name, ctx)) {
+        files.push({
+          path: `src/${ctx.namespace}/${dirName}/models/${fileName(model.name)}.py`,
+          content: dispLines.join('\n'),
+          integrateTarget: true,
+          overwriteExisting: true,
+        });
+      }
 
       if (!emittedModelSymbolsByDir.has(dirName)) emittedModelSymbolsByDir.set(dirName, []);
       emittedModelSymbolsByDir.get(dirName)!.push(model.name);
@@ -216,12 +221,14 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
       }
       lines.push('');
       lines.push(`${modelClassName}: TypeAlias = ${canonicalClassName}`);
-      files.push({
-        path: `src/${ctx.namespace}/${dirName}/models/${fileName(model.name)}.py`,
-        content: lines.join('\n'),
-        integrateTarget: true,
-        overwriteExisting: true,
-      });
+      if (isModelInScope(model.name, ctx)) {
+        files.push({
+          path: `src/${ctx.namespace}/${dirName}/models/${fileName(model.name)}.py`,
+          content: lines.join('\n'),
+          integrateTarget: true,
+          overwriteExisting: true,
+        });
+      }
       if (!emittedModelSymbolsByDir.has(dirName)) emittedModelSymbolsByDir.set(dirName, []);
       emittedModelSymbolsByDir.get(dirName)!.push(model.name);
       const aliasNatural = originalModelToService.get(model.name);
@@ -232,7 +239,9 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
     // Deduplicate fields that map to the same snake_case name
     const seenFieldNames = new Set<string>();
     const deduplicatedFields = model.fields.filter((f) => {
-      const pyName = fieldName(f.name);
+      // Dedup on the DOMAIN identifier (the dataclass attribute name), which
+      // honors a `domainName` override; the wire key stays `field.name`.
+      const pyName = domainFieldName(f);
       if (seenFieldNames.has(pyName)) return false;
       seenFieldNames.add(pyName);
       return true;
@@ -343,7 +352,8 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
     };
 
     for (const field of requiredFields) {
-      const pyFieldName = fieldName(field.name);
+      // DOMAIN identifier: the dataclass attribute name (honors `domainName`).
+      const pyFieldName = domainFieldName(field);
       const pyType = rewriteDiscriminatorType(resolveModelFieldType(field.type));
       if (field.description || field.deprecated) {
         const parts: string[] = [];
@@ -357,7 +367,8 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
     }
 
     for (const field of optionalFields) {
-      const pyFieldName = fieldName(field.name);
+      // DOMAIN identifier: the dataclass attribute name (honors `domainName`).
+      const pyFieldName = domainFieldName(field);
       const innerType =
         field.type.kind === 'nullable' ? resolveModelFieldType(field.type.inner) : resolveModelFieldType(field.type);
       const pyType = `Optional[${rewriteDiscriminatorType(innerType)}]`;
@@ -383,7 +394,8 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
     const fieldAssignmentLines: string[] = [];
 
     for (const field of [...requiredFields, ...optionalFields]) {
-      const pyFieldName = fieldName(field.name);
+      // DOMAIN identifier (LHS of `cls(...)`); the wire key below stays `field.name`.
+      const pyFieldName = domainFieldName(field);
       const wireKey = field.name; // Wire keys are snake_case from the spec
       const isRequired = !isOptionalField(model.name, field, ctx);
 
@@ -424,7 +436,8 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
     lines.push('        result: Dict[str, Any] = {}');
 
     for (const field of [...requiredFields, ...optionalFields]) {
-      const pyFieldName = fieldName(field.name);
+      // DOMAIN identifier (`self.<attr>`); the wire key below stays `field.name`.
+      const pyFieldName = domainFieldName(field);
       const wireKey = field.name;
       const isRequired = !isOptionalField(model.name, field, ctx);
 
@@ -451,12 +464,14 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
 
     lines.push('        return result');
 
-    files.push({
-      path: `src/${ctx.namespace}/${dirName}/models/${fileName(model.name)}.py`,
-      content: lines.join('\n'),
-      integrateTarget: true,
-      overwriteExisting: true,
-    });
+    if (isModelInScope(model.name, ctx)) {
+      files.push({
+        path: `src/${ctx.namespace}/${dirName}/models/${fileName(model.name)}.py`,
+        content: lines.join('\n'),
+        integrateTarget: true,
+        overwriteExisting: true,
+      });
+    }
     if (!emittedModelSymbolsByDir.has(dirName)) emittedModelSymbolsByDir.set(dirName, []);
     emittedModelSymbolsByDir.get(dirName)!.push(model.name);
     const regularNatural = originalModelToService.get(model.name);

package/src/python/naming.ts

@@ -50,6 +50,16 @@ export function fieldName(name: string): string {
   return toSnakeCase(name);
 }
 
+/**
+ * snake_case domain field name for a model field, honoring a `domainName`
+ * override (set via the `fieldHints` config) so a wire field can surface under
+ * a friendlier name. The wire name (still derived from `field.name`) is
+ * unaffected, so the API contract is preserved.
+ */
+export function domainFieldName(field: { name: string; domainName?: string }): string {
+  return toSnakeCase(field.domainName ?? field.name);
+}
+
 /**
  * Python builtins that should not be shadowed by parameter names.
  * When a path/query param name collides, suffix with underscore.

package/src/python/resources.ts

@@ -30,7 +30,7 @@ import {
   buildResolvedLookup,
   lookupMethodName,
   lookupResolved,
-  groupByMount,
+  scopedMountGroups,
   getOpDefaults,
   getOpInferFromClient,
   buildHiddenParams as buildHiddenParamsShared,
@@ -1056,12 +1056,12 @@ export function generateResources(services: Service[], ctx: EmitterContext): Gen
   const resolvedLookup = buildResolvedLookup(ctx);
   const files: GeneratedFile[] = [];
   const mountDirMap = buildMountDirMap(ctx);
-  const mountGroups = groupByMount(ctx);
+  const mountGroups = scopedMountGroups(ctx);
 
   // Build mount group entries. When resolved operations are available, group by
   // mount target. Otherwise fall back to one group per service (for tests).
   const entries: Array<{ name: string; operations: Operation[] }> =
-    mountGroups.size > 0
+    mountGroups.size > 0 || ctx.scopedServices?.size
       ? [...mountGroups].map(([name, group]) => ({ name, operations: group.operations }))
       : services.map((s) => ({ name: resolveClassName(s, ctx), operations: s.operations }));
 

package/src/python/tests.ts

@@ -13,6 +13,7 @@ import {
   className,
   fileName,
   fieldName,
+  domainFieldName,
   moduleName,
   resolveMethodName,
   buildMountDirMap,
@@ -24,7 +25,7 @@ import { generateFixtures, generateModelFixture } from './fixtures.js';
 import { isListWrapperModel, isListMetadataModel } from './models.js';
 import { collectNonPaginatedResponseModelNames, collectReferencedListMetadataModels } from '../shared/model-utils.js';
 import {
-  groupByMount,
+  scopedMountGroups,
   buildResolvedLookup,
   lookupResolved,
   buildHiddenParams,
@@ -117,9 +118,9 @@ export function generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
   const accessPaths = buildServiceAccessPaths(spec.services, ctx);
 
   // Generate per-mount-target test files (merges all sub-services into one file)
-  const mountGroups = groupByMount(ctx);
+  const mountGroups = scopedMountGroups(ctx);
   const testEntries: Array<{ name: string; operations: Operation[]; resolvedOps?: ResolvedOperation[] }> =
-    mountGroups.size > 0
+    mountGroups.size > 0 || ctx.scopedServices?.size
       ? [...mountGroups].map(([name, group]) => ({
           name,
           operations: group.operations,
@@ -1026,12 +1027,13 @@ function pickAssertableFields(
       // Skip strings containing characters that are hard to represent as Python literals
       if (val.includes('"') || val.includes("'") || val.includes('{') || val.includes('\\') || val.includes('\n'))
         continue;
-      results.push({ field: fieldName(f.name), value: `"${val}"` });
+      // DOMAIN identifier: asserted as `result.<attr>` (honors `domainName`).
+      results.push({ field: domainFieldName(f), value: `"${val}"` });
     } else if (typeof val === 'boolean') {
       // Use "is True/False" to satisfy ruff E712
-      results.push({ field: fieldName(f.name), value: val ? 'True' : 'False', isBool: true });
+      results.push({ field: domainFieldName(f), value: val ? 'True' : 'False', isBool: true });
     } else if (typeof val === 'number') {
-      results.push({ field: fieldName(f.name), value: String(val) });
+      results.push({ field: domainFieldName(f), value: String(val) });
     }
   }
   return results;
@@ -1114,7 +1116,9 @@ function buildTestArgs(op: Operation, spec: ApiSpec, hiddenParams?: Set<string>)
       if (plan.hasBody && op.requestBody?.kind === 'model') {
         const rbName = op.requestBody.name;
         const bodyModel = spec.models.find((m) => m.name === rbName);
-        if (bodyModel?.fields.some((f) => fieldName(f.name) === fieldName(param.name))) continue;
+        // Compare the body field's DOMAIN identifier (honors `domainName`)
+        // against the param kwarg name; the param has no domainName override.
+        if (bodyModel?.fields.some((f) => domainFieldName(f) === fieldName(param.name))) continue;
       }
       if (param.required && !pathParamNames.has(fieldName(param.name))) {
         args.push(`${fieldName(param.name)}=${generateTestValue(param.type, param.name)}`);
@@ -1511,10 +1515,11 @@ function generateModelRoundTripTests(spec: ApiSpec, ctx: EmitterContext): Genera
     // don't have a to_dict() and their round-trip semantics differ.
     if (model.fields.length === 0) continue;
     if ((model as any).discriminator) continue;
-    // Deduplicate fields that map to the same snake_case name (mirrors models.ts)
+    // Deduplicate fields by DOMAIN identifier (mirrors models.ts, which honors
+    // `domainName`); the wire key stays `field.name`.
     const seenFieldNames = new Set<string>();
     const dedupFields = model.fields.filter((f) => {
-      const pyName = fieldName(f.name);
+      const pyName = domainFieldName(f);
       if (seenFieldNames.has(pyName)) return false;
       seenFieldNames.add(pyName);
       return true;

package/src/ruby/enums.ts

@@ -1,6 +1,7 @@
 import type { Enum, EmitterContext, GeneratedFile } from '@workos/oagen';
 import { toUpperSnakeCase } from '@workos/oagen';
 import { className, fileName } from './naming.js';
+import { isEnumInScope } from '../shared/resolved-ops.js';
 
 /**
  * Generate Ruby enum class files.
@@ -9,7 +10,6 @@ import { className, fileName } from './naming.js';
  * and a frozen `ALL` array of all values.
  */
 export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile[] {
-  void ctx;
   if (enums.length === 0) return [];
 
   const files: GeneratedFile[] = [];
@@ -17,6 +17,9 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
 
   for (const enumDef of enums) {
     const cls = className(enumDef.name);
+    // FR-1.4: write the per-enum file only when in scope. Out-of-scope enum
+    // files are left untouched on disk; Zeitwerk autoloads them by path.
+    const enumInScope = isEnumInScope(enumDef.name, ctx);
 
     // If this enum duplicates another (by value set), emit a Ruby constant
     // alias. Zeitwerk autoloads the canonical when the alias is first
@@ -30,12 +33,14 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
       lines.push(`    ${cls} = ${canonicalCls}`);
       lines.push('  end');
       lines.push('end');
-      files.push({
-        path: `lib/workos/types/${fileName(enumDef.name)}.rb`,
-        content: lines.join('\n'),
-        integrateTarget: true,
-        overwriteExisting: true,
-      });
+      if (enumInScope) {
+        files.push({
+          path: `lib/workos/types/${fileName(enumDef.name)}.rb`,
+          content: lines.join('\n'),
+          integrateTarget: true,
+          overwriteExisting: true,
+        });
+      }
       continue;
     }
 
@@ -60,12 +65,14 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
       lines.push('    end');
       lines.push('  end');
       lines.push('end');
-      files.push({
-        path: `lib/workos/types/${fileName(enumDef.name)}.rb`,
-        content: lines.join('\n'),
-        integrateTarget: true,
-        overwriteExisting: true,
-      });
+      if (enumInScope) {
+        files.push({
+          path: `lib/workos/types/${fileName(enumDef.name)}.rb`,
+          content: lines.join('\n'),
+          integrateTarget: true,
+          overwriteExisting: true,
+        });
+      }
       continue;
     }
 
@@ -108,12 +115,14 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
     lines.push('  end');
     lines.push('end');
 
-    files.push({
-      path: `lib/workos/types/${fileName(enumDef.name)}.rb`,
-      content: lines.join('\n'),
-      integrateTarget: true,
-      overwriteExisting: true,
-    });
+    if (enumInScope) {
+      files.push({
+        path: `lib/workos/types/${fileName(enumDef.name)}.rb`,
+        content: lines.join('\n'),
+        integrateTarget: true,
+        overwriteExisting: true,
+      });
+    }
   }
 
   return files;

package/src/ruby/index.ts

@@ -16,6 +16,7 @@ import { generateTests } from './tests.js';
 import { buildOperationsMap } from './manifest.js';
 import { generateRbiFiles } from './rbi.js';
 import { enrichModelsFromSpec, getSyntheticEnums } from '../shared/model-utils.js';
+import { AUTOGEN_NOTICE } from '../shared/file-header.js';
 
 /** Ensure every generated file's content ends with a trailing newline. */
 function ensureTrailingNewlines(files: GeneratedFile[]): GeneratedFile[] {
@@ -93,7 +94,7 @@ export const rubyEmitter: Emitter = {
   },
 
   fileHeader(): string {
-    return `# frozen_string_literal: true\n\n# This file is auto-generated by oagen. Do not edit.`;
+    return `# frozen_string_literal: true\n\n# ${AUTOGEN_NOTICE}`;
   },
 
   formatCommand(targetDir: string): FormatCommand | null {