@workos/oagen-emitters 0.2.1 → 0.4.0

package/src/kotlin/type-map.ts

@@ -0,0 +1,123 @@
+import type { TypeRef, PrimitiveType, UnionType } from '@workos/oagen';
+import { mapTypeRef as irMapTypeRef } from '@workos/oagen';
+import { className } from './naming.js';
+import { enumCanonicalMap } from './enums.js';
+
+/** Resolve an enum name through the canonical map (identity when no alias). */
+function resolveEnumName(name: string): string {
+  return className(enumCanonicalMap.get(name) ?? name);
+}
+
+/**
+ * Map an IR TypeRef to a non-nullable Kotlin type expression.
+ *
+ * Kotlin's type system marks nullability at use-sites (`T?`). Optional fields
+ * on generated models append `?` to the output of this function.
+ */
+export function mapTypeRef(ref: TypeRef): string {
+  return irMapTypeRef<string>(ref, {
+    primitive: mapPrimitive,
+    array: (_ref, items) => `List<${items}>`,
+    model: (r) => className(r.name),
+    enum: (r) => resolveEnumName(r.name),
+    union: (r, variants) => joinUnionVariants(r, variants),
+    nullable: (_ref, inner) => (inner.endsWith('?') ? inner : `${inner}?`),
+    literal: (r) => {
+      if (r.value === null) return 'Any?';
+      if (typeof r.value === 'string') return 'String';
+      if (typeof r.value === 'number') return Number.isInteger(r.value) ? 'Long' : 'Double';
+      if (typeof r.value === 'boolean') return 'Boolean';
+      return 'Any';
+    },
+    map: (_ref, value) => `Map<String, ${value}>`,
+  });
+}
+
+/**
+ * Map an IR TypeRef to a nullable Kotlin type expression (always appends `?`).
+ * Useful for optional fields on models / request options.
+ */
+export function mapTypeRefOptional(ref: TypeRef): string {
+  const baseType = mapTypeRef(ref);
+  return baseType.endsWith('?') ? baseType : `${baseType}?`;
+}
+
+/**
+ * Is the given IR TypeRef a primitive value? Useful when deciding whether a
+ * nullable field needs an explicit `= null` default.
+ */
+export function isValueTypeRef(ref: TypeRef): boolean {
+  if (ref.kind === 'enum') return true;
+  if (ref.kind === 'primitive') {
+    if (ref.format === 'date-time') return true;
+    switch (ref.type) {
+      case 'integer':
+      case 'number':
+      case 'boolean':
+        return true;
+      default:
+        return false;
+    }
+  }
+  return false;
+}
+
+function mapPrimitive(ref: PrimitiveType): string {
+  if (ref.format === 'binary') return 'ByteArray';
+  if (ref.format === 'int32') return 'Int';
+  if (ref.format === 'int64') return 'Long';
+  if (ref.format === 'date-time') return 'OffsetDateTime';
+  switch (ref.type) {
+    case 'string':
+      return 'String';
+    case 'integer':
+      return 'Long';
+    case 'number':
+      return 'Double';
+    case 'boolean':
+      return 'Boolean';
+    case 'unknown':
+      return 'Any';
+  }
+}
+
+/**
+ * Track discriminated unions so the model generator can emit the appropriate
+ * Jackson `@JsonTypeInfo` / `@JsonSubTypes` annotations on the sealed parent.
+ */
+export const discriminatedUnions = new Map<
+  string,
+  { property: string; mapping: Record<string, string>; variantTypes: string[] }
+>();
+
+function joinUnionVariants(ref: UnionType, variants: string[]): string {
+  if (ref.compositionKind === 'allOf') {
+    return variants[0] ?? 'Any';
+  }
+  const unique = [...new Set(variants)];
+  if (unique.length === 1) return unique[0];
+
+  if (ref.discriminator && ref.discriminator.mapping) {
+    const baseName = unique[0];
+    discriminatedUnions.set(baseName, {
+      property: ref.discriminator.property,
+      mapping: ref.discriminator.mapping,
+      variantTypes: unique,
+    });
+    // Use the base sealed type; Jackson @JsonTypeInfo handles variant selection.
+    return baseName;
+  }
+
+  // Non-discriminated unions fall back to the Kotlin top type. A generic
+  // AnyOf<> is planned for a future phase if emitter tests prove it necessary.
+  return 'Any';
+}
+
+/** Kotlin imports implied by a given type expression. Caller collects into a set. */
+export function implicitImportsFor(kotlinType: string): string[] {
+  const imports: string[] = [];
+  if (/\bOffsetDateTime\b/.test(kotlinType)) {
+    imports.push('java.time.OffsetDateTime');
+  }
+  return imports;
+}

package/src/kotlin/wrappers.ts

@@ -0,0 +1,168 @@
+import type { EmitterContext, ResolvedOperation, ResolvedWrapper, Parameter } from '@workos/oagen';
+import { className, propertyName, ktLiteral, clientFieldExpression, escapeReserved } from './naming.js';
+import { mapTypeRef, mapTypeRefOptional } from './type-map.js';
+import { resolveWrapperParams } from '../shared/wrapper-utils.js';
+import { sortPathParamsByTemplateOrder } from './resources.js';
+
+/**
+ * Emit Kotlin wrapper methods for a union-split operation. Each wrapper
+ * method takes only the fields it needs for its variant, fills in the
+ * operation-level defaults and client-inferred values, and posts to the
+ * underlying operation.
+ *
+ * Returns a list of lines (with leading indentation suitable for inclusion
+ * inside the service class body).
+ */
+export function generateWrapperMethods(resolvedOp: ResolvedOperation, ctx: EmitterContext): string[] {
+  if (!resolvedOp.wrappers || resolvedOp.wrappers.length === 0) return [];
+
+  const out: string[] = [];
+  for (const wrapper of resolvedOp.wrappers) {
+    if (out.length > 0) out.push('');
+    for (const line of emitWrapperMethod(resolvedOp, wrapper, ctx)) out.push(line);
+  }
+  return out;
+}
+
+function emitWrapperMethod(resolvedOp: ResolvedOperation, wrapper: ResolvedWrapper, ctx: EmitterContext): string[] {
+  const op = resolvedOp.operation;
+  const method = propertyName(wrapper.name);
+  const resolvedParams = resolveWrapperParams(wrapper, ctx);
+  const responseClass = wrapper.responseModelName ? className(wrapper.responseModelName) : null;
+
+  const pathParams = sortPathParamsByTemplateOrder(op);
+
+  const lines: string[] = [];
+
+  // Build KDoc from operation description + @param docs for each wrapper param.
+  const kdocLines: string[] = [];
+  const opDesc = (op.description ?? '').trim();
+  const wrapperHumanName = method.replace(/([a-z])([A-Z])/g, '$1 $2').toLowerCase();
+  if (opDesc) {
+    kdocLines.push(opDesc.split('\n')[0]);
+  } else {
+    kdocLines.push(`${wrapperHumanName.charAt(0).toUpperCase()}${wrapperHumanName.slice(1)}.`);
+  }
+  const paramDocs: string[] = [];
+  for (const pp of pathParams) {
+    if (pp.description?.trim()) {
+      paramDocs.push(`@param ${propertyName(pp.name)} ${escapeKdoc(pp.description.split('\n')[0].trim())}`);
+    }
+  }
+  for (const rp of resolvedParams) {
+    const desc = rp.field?.description?.trim();
+    if (desc) {
+      paramDocs.push(`@param ${propertyName(rp.paramName)} ${escapeKdoc(desc.split('\n')[0])}`);
+    }
+  }
+  if (responseClass) {
+    paramDocs.push(`@return the ${responseClass}`);
+  }
+  if (paramDocs.length > 0 || kdocLines.length > 0) {
+    lines.push('  /**');
+    for (const l of kdocLines) lines.push(`   * ${escapeKdoc(l)}`);
+    if (paramDocs.length > 0) {
+      lines.push('   *');
+      for (const p of paramDocs) lines.push(`   * ${p}`);
+    }
+    lines.push('   */');
+  }
+
+  lines.push('  @JvmOverloads');
+
+  // Build the method parameter list: path params, wrapper params, requestOptions
+  const params: string[] = [];
+  for (const pp of pathParams) params.push(`    ${propertyName(pp.name)}: String`);
+  for (const rp of resolvedParams) {
+    const paramName = propertyName(rp.paramName);
+    const kotlinType = rp.field
+      ? rp.isOptional
+        ? mapTypeRefOptional(rp.field.type)
+        : mapTypeRef(rp.field.type)
+      : rp.isOptional
+        ? 'String?'
+        : 'String';
+    const trailer = rp.isOptional ? ' = null' : '';
+    params.push(`    ${paramName}: ${kotlinType}${trailer}`);
+  }
+  params.push('    requestOptions: RequestOptions? = null');
+
+  const returnClause = responseClass ? `: ${responseClass}` : '';
+  if (params.length === 1) {
+    const single = params[0].replace(/^\s+/, '');
+    lines.push(`  fun ${escapeReserved(method)}(${single})${returnClause} {`);
+  } else {
+    lines.push(`  fun ${escapeReserved(method)}(`);
+    for (let i = 0; i < params.length; i++) {
+      const suffix = i === params.length - 1 ? '' : ',';
+      lines.push(`${params[i]}${suffix}`);
+    }
+    lines.push(`  )${returnClause} {`);
+  }
+
+  // Build body using bodyOf() — consistent with non-wrapper methods.
+  // bodyOf() automatically drops null optional values.
+  const bodyEntries: string[] = [];
+  for (const rp of resolvedParams) {
+    const paramName = propertyName(rp.paramName);
+    bodyEntries.push(`      ${ktLiteral(rp.paramName)} to ${paramName}`);
+  }
+  for (const [k, v] of Object.entries(wrapper.defaults ?? {})) {
+    bodyEntries.push(`      ${ktLiteral(k)} to ${ktLiteral(v)}`);
+  }
+  for (const k of wrapper.inferFromClient ?? []) {
+    bodyEntries.push(`      ${ktLiteral(k)} to workos.${clientFieldExpression(k)}`);
+  }
+  if (bodyEntries.length > 0) {
+    lines.push(`    val body =`);
+    lines.push(`      bodyOf(`);
+    for (let i = 0; i < bodyEntries.length; i++) {
+      const sep = i === bodyEntries.length - 1 ? '' : ',';
+      lines.push(`  ${bodyEntries[i]}${sep}`);
+    }
+    lines.push(`      )`);
+  } else {
+    lines.push(`    val body = linkedMapOf<String, Any?>()`);
+  }
+
+  const pathExpr = buildPathExpr(op.path, pathParams);
+  const httpMethod = op.httpMethod.toUpperCase();
+
+  lines.push(`    val config =`);
+  lines.push(`      RequestConfig(`);
+  lines.push(`        method = ${ktLiteral(httpMethod)},`);
+  lines.push(`        path = ${pathExpr},`);
+  lines.push(`        body = body,`);
+  if (op.requestBodyEncoding === 'form-urlencoded') {
+    // Some ops (SSO token, User Management authenticate) are form-encoded.
+    // Rewrite as formBody mapping string→string instead of JSON body.
+    // Fallback: leave body as JSON — the API accepts JSON for these too.
+  }
+  lines.push(`        requestOptions = requestOptions`);
+  lines.push(`      )`);
+
+  if (responseClass) {
+    lines.push(`    return workos.baseClient.request(config, ${responseClass}::class.java)`);
+  } else {
+    lines.push(`    workos.baseClient.requestVoid(config)`);
+  }
+
+  lines.push('  }');
+  return lines;
+}
+
+function escapeKdoc(s: string): string {
+  return s.replace(/\*\//g, '*\u200b/');
+}
+
+function buildPathExpr(path: string, pathParams: Parameter[]): string {
+  if (pathParams.length === 0) return ktLiteral(path);
+  let result = path;
+  for (const pp of pathParams) {
+    const placeholder = `{${pp.name}}`;
+    const propName = propertyName(pp.name);
+    const replacement = /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(propName) ? `\$${propName}` : `\${${propName}}`;
+    result = result.replaceAll(placeholder, replacement);
+  }
+  return `"${result.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}

package/src/node/client.ts

@@ -1,4 +1,7 @@
+import fs from 'node:fs';
+import path from 'node:path';
 import type { ApiSpec, AuthScheme, EmitterContext, GeneratedFile, Service } from '@workos/oagen';
+import { collectReferencedNames } from '@workos/oagen';
 import { fileName, resolveServiceDir, servicePropertyName, resolveInterfaceName, wireInterfaceName } from './naming.js';
 import {
   docComment,
@@ -15,9 +18,7 @@ export function generateClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFil
   files.push(generateWorkOSClient(spec, ctx));
   files.push(...generateServiceBarrels(spec, ctx));
   files.push(generateBarrel(spec, ctx));
-  files.push(generateWorkerBarrel(spec, ctx));
-  files.push(generatePackageJson(ctx));
-  files.push(generateTsConfig());
+  // worker barrel, package.json, tsconfig.json are now hand-maintained in the target SDK
 
   return files;
 }
@@ -86,6 +87,15 @@ function generateWorkOSClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
     const resolvedName = resolveResourceClassName(service, ctx);
     const propName = servicePropertyName(resolvedName);
     if (existingProps.has(propName)) continue;
+    // Propagate `@deprecated` from the service class to the property so
+    // IDEs surface the strikethrough at `workos.xyz` access sites, not
+    // just when users `new Xyz()` directly.  TS's deprecation-lint reads
+    // the property JSDoc, not the underlying type declaration.
+    const classDeprecation = ctx.apiSurface?.classes?.[resolvedName]?.deprecationMessage;
+    if (classDeprecation !== undefined) {
+      const body = classDeprecation ? ` ${classDeprecation}` : '';
+      lines.push(`  /** @deprecated${body} */`);
+    }
     lines.push(`  readonly ${propName} = new ${resolvedName}(this);`);
   }
 
@@ -128,47 +138,36 @@ function generateServiceBarrels(spec: ApiSpec, ctx: EmitterContext): GeneratedFi
   // exports a name (e.g., AuditLogSchema from create-audit-log-schema-options),
   // the generated model with the same name must be skipped to prevent the
   // merger from adding a duplicate `export *` that causes TS2308.
+  //
+  // Also track baseline file stems per directory so we can detect when the
+  // barrel needs updating with new export lines (see hasNewExports below).
+  const dirSymbolsFromBaseline = new Map<string, Set<string>>();
+  const seedFromBaseline = (sourceFile: string, name: string) => {
+    const match = sourceFile.match(/^src\/([^/]+)\/interfaces\/(.+)\.ts$/);
+    if (!match) return;
+    const dirName = match[1];
+    const fileStem = match[2];
+    if (!dirSymbols.has(dirName)) dirSymbols.set(dirName, new Set());
+    dirSymbols.get(dirName)!.add(name);
+    if (!dirSymbolsFromBaseline.has(dirName)) dirSymbolsFromBaseline.set(dirName, new Set());
+    dirSymbolsFromBaseline.get(dirName)!.add(fileStem);
+  };
   if (ctx.apiSurface?.interfaces) {
     for (const [name, iface] of Object.entries(ctx.apiSurface.interfaces)) {
       const sourceFile = (iface as any).sourceFile as string | undefined;
-      if (!sourceFile) continue;
-      // Match paths like "src/audit-logs/interfaces/foo.interface.ts" to directory "audit-logs"
-      const match = sourceFile.match(/^src\/([^/]+)\/interfaces\//);
-      if (match) {
-        const dirName = match[1];
-        if (!dirSymbols.has(dirName)) {
-          dirSymbols.set(dirName, new Set());
-        }
-        dirSymbols.get(dirName)!.add(name);
-      }
+      if (sourceFile) seedFromBaseline(sourceFile, name);
     }
   }
   if (ctx.apiSurface?.enums) {
     for (const [name, enumDef] of Object.entries(ctx.apiSurface.enums)) {
       const sourceFile = (enumDef as any).sourceFile as string | undefined;
-      if (!sourceFile) continue;
-      const match = sourceFile.match(/^src\/([^/]+)\/interfaces\//);
-      if (match) {
-        const dirName = match[1];
-        if (!dirSymbols.has(dirName)) {
-          dirSymbols.set(dirName, new Set());
-        }
-        dirSymbols.get(dirName)!.add(name);
-      }
+      if (sourceFile) seedFromBaseline(sourceFile, name);
     }
   }
   if (ctx.apiSurface?.typeAliases) {
     for (const [name, alias] of Object.entries(ctx.apiSurface.typeAliases)) {
       const sourceFile = (alias as any).sourceFile as string | undefined;
-      if (!sourceFile) continue;
-      const match = sourceFile.match(/^src\/([^/]+)\/interfaces\//);
-      if (match) {
-        const dirName = match[1];
-        if (!dirSymbols.has(dirName)) {
-          dirSymbols.set(dirName, new Set());
-        }
-        dirSymbols.get(dirName)!.add(name);
-      }
+      if (sourceFile) seedFromBaseline(sourceFile, name);
     }
   }
 
@@ -187,8 +186,12 @@ function generateServiceBarrels(spec: ApiSpec, ctx: EmitterContext): GeneratedFi
   // Models -> service directories
   // Skip list wrapper and list metadata models — they use shared List<T>/ListMetadata
   // from common utils, so no per-resource interface file is generated.
+  // Also skip unreachable models — oagen only passes service-referenced models
+  // to generateModels, so unreachable models have no interface file to export.
+  const barrelReachable = collectReferencedNames(spec.services, spec.models);
   for (const model of spec.models) {
     if (isListMetadataModel(model) || isListWrapperModel(model)) continue;
+    if (!barrelReachable.models.has(model.name)) continue;
     const service = modelToService.get(model.name);
     const dirName = resolveDir(service);
     if (!dirExports.has(dirName)) {
@@ -240,14 +243,96 @@ function generateServiceBarrels(spec: ApiSpec, ctx: EmitterContext): GeneratedFi
   }
 
   for (const [dirName, exports] of dirExports) {
-    // Deduplicate (an enum and model could theoretically share a file name)
-    const uniqueExports = [...new Set(exports)];
+    const exportSet = new Set(exports);
+
+    // When integrating into an existing SDK, include baseline exports from
+    // the api-surface so the barrel is comprehensive.  This ensures stale
+    // entries (e.g., renamed files from previous generations) are removed
+    // when overwriteExisting replaces the barrel.
+    if (ctx.apiSurface) {
+      const addBaselineExports = (items: Record<string, any> | undefined) => {
+        if (!items) return;
+        for (const item of Object.values(items)) {
+          const sourceFile = (item as any).sourceFile as string | undefined;
+          if (!sourceFile) continue;
+          const match = sourceFile.match(/^src\/([^/]+)\/interfaces\/(.+)\.ts$/);
+          if (match && match[1] === dirName) {
+            exportSet.add(`export * from './${match[2].replace(/\.ts$/, '')}';`);
+          }
+        }
+      };
+      addBaselineExports(ctx.apiSurface.interfaces);
+      addBaselineExports(ctx.apiSurface.typeAliases);
+      addBaselineExports(ctx.apiSurface.enums);
+
+      // Scan the target directory for interface files not captured by the
+      // api-surface (e.g., list wrappers, hand-written types).  Only add
+      // files whose exported symbols don't collide with symbols already
+      // claimed by another directory's barrel (TS2308 prevention).
+      if (ctx.targetDir) {
+        const interfacesDir = path.join(ctx.targetDir, 'src', dirName, 'interfaces');
+        const symbols = dirSymbols.get(dirName) ?? new Set<string>();
+        try {
+          for (const entry of fs.readdirSync(interfacesDir)) {
+            if (entry === 'index.ts') continue;
+            if (!entry.endsWith('.ts')) continue;
+            const stem = entry.replace(/\.ts$/, '');
+            const exportLine = `export * from './${stem}';`;
+            if (exportSet.has(exportLine)) continue;
+
+            // Extract exported symbol names from the file to check for conflicts
+            const content = fs.readFileSync(path.join(interfacesDir, entry), 'utf-8');
+            const exportedNames: string[] = [];
+            for (const m of content.matchAll(/export\s+(?:interface|type|enum|class|const|function)\s+(\w+)/g)) {
+              exportedNames.push(m[1]);
+            }
+
+            // Skip if any exported name collides with a symbol already
+            // claimed by any file (same or different directory)
+            const hasCollision = exportedNames.some((name) => globalExistingSymbols.has(name));
+            if (hasCollision) continue;
+
+            // Safe to add — register symbols and include in barrel
+            for (const name of exportedNames) {
+              symbols.add(name);
+              globalExistingSymbols.add(name);
+            }
+            exportSet.add(exportLine);
+          }
+        } catch {
+          // Directory doesn't exist in target — nothing to scan
+        }
+      }
+    }
+
+    // Deduplicate and sort
+    const uniqueExports = [...exportSet];
     uniqueExports.sort();
-    files.push({
-      path: `src/${dirName}/interfaces/index.ts`,
-      content: uniqueExports.join('\n'),
-      skipIfExists: true,
-    });
+
+    if (ctx.apiSurface) {
+      // Integration mode: overwrite the barrel so stale entries are removed.
+      files.push({
+        path: `src/${dirName}/interfaces/index.ts`,
+        content: uniqueExports.join('\n'),
+        overwriteExisting: true,
+      });
+    } else {
+      // Standalone generation: only update if there are new exports.
+      const baselineSymbols = dirSymbolsFromBaseline.get(dirName);
+      const hasNewExports = baselineSymbols
+        ? uniqueExports.some((exp) => {
+            const match = exp.match(/from '\.\/(.*?)'/);
+            if (!match) return false;
+            return !baselineSymbols.has(match[1]);
+          })
+        : false;
+
+      files.push({
+        path: `src/${dirName}/interfaces/index.ts`,
+        content: uniqueExports.join('\n'),
+        skipIfExists: !hasNewExports,
+      });
+    }
   }
 
   return files;
@@ -457,7 +542,11 @@ function generateBarrel(spec: ApiSpec, ctx: EmitterContext): GeneratedFile {
   }
 
   // Unassigned models (common) — use barrel if any exist
-  const unassignedModels = spec.models.filter((m) => !modelToService.has(m.name));
+  // Filter to reachable models only: oagen's generateAllFiles passes only
+  // service-referenced models to generateModels, so unreachable models
+  // never get interface files.  Exporting them here would create broken imports.
+  const reachable = collectReferencedNames(spec.services, spec.models);
+  const unassignedModels = spec.models.filter((m) => !modelToService.has(m.name) && reachable.models.has(m.name));
   const commonEnums = spec.enums.filter((e) => {
     const enumService = findEnumService(e.name, spec.services);
     return !enumService;
@@ -527,23 +616,6 @@ function generateBarrel(spec: ApiSpec, ctx: EmitterContext): GeneratedFile {
   };
 }
 
-/**
- * Generate a worker-compatible barrel file that re-exports everything from
- * the main barrel. This keeps type exports in sync automatically.
- */
-function generateWorkerBarrel(_spec: ApiSpec, _ctx: EmitterContext): GeneratedFile {
-  const lines: string[] = [];
-
-  // Re-export everything from the main index — keeps type exports in sync
-  lines.push("export * from './index';");
-
-  return {
-    path: 'src/index.worker.ts',
-    content: lines.join('\n'),
-    skipIfExists: true,
-  };
-}
-
 function findEnumService(enumName: string, services: Service[]): string | undefined {
   for (const service of services) {
     for (const op of service.operations) {
@@ -610,62 +682,3 @@ function serverConstName(description: string): string {
       .toUpperCase()
   );
 }
-
-function generatePackageJson(ctx: EmitterContext): GeneratedFile {
-  const pkg = {
-    name: `@${ctx.namespace}/sdk`,
-    version: '0.0.0',
-    type: 'module',
-    main: 'src/index.ts',
-    types: 'src/index.ts',
-    exports: {
-      '.': './src/index.ts',
-    },
-    scripts: {
-      test: 'jest',
-      build: 'tsc',
-    },
-    devDependencies: {
-      typescript: '^5.0.0',
-      jest: '^29.0.0',
-      'jest-fetch-mock': '^3.0.0',
-      '@types/jest': '^29.0.0',
-      'ts-jest': '^29.0.0',
-    },
-  };
-
-  return {
-    path: 'package.json',
-    content: JSON.stringify(pkg, null, 2),
-    skipIfExists: true,
-    integrateTarget: false,
-  };
-}
-
-function generateTsConfig(): GeneratedFile {
-  const config = {
-    compilerOptions: {
-      target: 'ES2020',
-      module: 'CommonJS',
-      lib: ['ES2020'],
-      declaration: true,
-      strict: true,
-      exactOptionalPropertyTypes: true,
-      esModuleInterop: true,
-      skipLibCheck: true,
-      forceConsistentCasingInFileNames: true,
-      resolveJsonModule: true,
-      outDir: './lib',
-      rootDir: './src',
-    },
-    include: ['src/**/*'],
-    exclude: ['node_modules', 'lib', '**/*.spec.ts'],
-  };
-
-  return {
-    path: 'tsconfig.json',
-    content: JSON.stringify(config, null, 2),
-    skipIfExists: true,
-    integrateTarget: false,
-  };
-}

package/src/node/enums.ts

@@ -19,6 +19,15 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
     // Check baseline surface for representation and values
     const baselineEnum = ctx.apiSurface?.enums?.[enumDef.name];
     const baselineAlias = ctx.apiSurface?.typeAliases?.[enumDef.name];
+    const generatedPath = `src/${dirName}/interfaces/${fileName(enumDef.name)}.interface.ts`;
+
+    // If the baseline already provides this enum from a different file (e.g., `.enum.ts`),
+    // skip generation to avoid duplicate exports from the same barrel.
+    const baselineSourceFile = (baselineEnum as any)?.sourceFile ?? (baselineAlias as any)?.sourceFile;
+    if (baselineSourceFile && baselineSourceFile !== generatedPath) {
+      continue;
+    }
+
     const lines: string[] = [];
 
     // Track whether the generated content has new values not in the baseline.