@workos/oagen-emitters 0.14.4 → 0.15.1

package/dist/plugin.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workos/oagen-emitters",
-  "version": "0.14.4",
+  "version": "0.15.1",
   "description": "WorkOS' oagen emitters",
   "license": "MIT",
   "author": "WorkOS",
@@ -38,22 +38,22 @@
     "prepare": "husky"
   },
   "devDependencies": {
-    "@commitlint/cli": "^21.0.1",
-    "@commitlint/config-conventional": "^21.0.1",
+    "@commitlint/cli": "^21.0.2",
+    "@commitlint/config-conventional": "^21.0.2",
     "@types/node": "^25.9.1",
     "husky": "^9.1.7",
     "oxfmt": "^0.52.0",
     "oxlint": "^1.67.0",
     "prettier": "^3.8.3",
-    "tsdown": "^0.22.0",
-    "tsx": "^4.22.3",
+    "tsdown": "^0.22.1",
+    "tsx": "^4.22.4",
     "typescript": "^6.0.3",
-    "vitest": "^4.1.7"
+    "vitest": "^4.1.8"
   },
   "engines": {
     "node": ">=24.10.0"
   },
   "dependencies": {
-    "@workos/oagen": "^0.21.0"
+    "@workos/oagen": "^0.21.1"
   }
 }

package/renovate.json

@@ -1,66 +1,6 @@
 {
   "$schema": "https://docs.renovatebot.com/renovate-schema.json",
   "extends": [
-    "github>workos/renovate-config"
-  ],
-  "dependencyDashboard": false,
-  "schedule": [
-    "on the 15th day of the month before 12pm"
-  ],
-  "timezone": "UTC",
-  "rebaseWhen": "conflicted",
-  "packageRules": [
-    {
-      "matchManagers": [
-        "github-actions"
-      ],
-      "pinDigests": true,
-      "extractVersion": "^v(?<version>\\d+\\.\\d+\\.\\d+)$"
-    },
-    {
-      "matchUpdateTypes": [
-        "minor",
-        "patch"
-      ],
-      "automerge": true,
-      "groupName": "minor and patch updates"
-    },
-    {
-      "matchUpdateTypes": [
-        "major"
-      ],
-      "automerge": false
-    },
-    {
-      "matchUpdateTypes": [
-        "digest"
-      ],
-      "automerge": false
-    },
-    {
-      "matchManagers": [
-        "github-actions"
-      ],
-      "matchUpdateTypes": [
-        "minor",
-        "patch",
-        "digest",
-        "pinDigest"
-      ],
-      "groupName": "github actions non-major",
-      "groupSlug": "github-actions-non-major",
-      "automerge": true
-    },
-    {
-      "matchManagers": [
-        "github-actions"
-      ],
-      "matchUpdateTypes": [
-        "major"
-      ],
-      "groupName": "github actions major",
-      "groupSlug": "github-actions-major",
-      "automerge": false
-    }
+    "github>workos/renovate-config:public"
   ]
 }

package/src/go/client.ts

@@ -17,7 +17,7 @@ export function generateClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFil
 }
 
 /**
- * Non-spec services marked with `hasClientAccessor: true` (passwordless, vault)
+ * Non-spec services marked with `hasClientAccessor: true` (e.g. passwordless)
  * 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.

package/src/go/enums.ts

@@ -96,6 +96,8 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
     content: lines.join('\n'),
     overwriteExisting: true,
   });
+  const eventConstantsFile = generateEventConstantsFile(enums);
+  if (eventConstantsFile) files.push(eventConstantsFile);
 
   return files;
 }
@@ -173,6 +175,81 @@ function collectEnumAliasOf(enums: Enum[]): Map<string, string> {
   return aliasOf;
 }
 
+function generateEventConstantsFile(enums: Enum[]): GeneratedFile | null {
+  const enumDef = findWebhookEventEnum(enums);
+  if (!enumDef) return null;
+
+  const lines: string[] = [];
+  lines.push('package events');
+  lines.push('');
+  lines.push('// Event is a WorkOS event type.');
+  lines.push('type Event string');
+  lines.push('');
+  lines.push('const (');
+
+  const seenValues = new Set<string>();
+  const usedNames = new Set<string>();
+  for (const value of enumDef.values) {
+    const valueStr = String(value.value);
+    if (seenValues.has(valueStr)) continue;
+    seenValues.add(valueStr);
+
+    const constName = uniqueEventConstantName(valueStr, usedNames);
+    usedNames.add(constName);
+
+    if (value.description) {
+      lines.push(`\t// ${constName} is ${value.description}.`);
+    }
+    if (value.deprecated) {
+      if (value.description) lines.push('\t//');
+      lines.push('\t// Deprecated: this value is deprecated.');
+    }
+    // Keep constants untyped so callers can use them as plain strings,
+    // events.Event values, or typed root-package enum values.
+    lines.push(`\t${constName} = "${escapeGoString(valueStr)}"`);
+  }
+
+  lines.push(')');
+  lines.push('');
+
+  return {
+    path: 'pkg/events/events.go',
+    content: lines.join('\n'),
+    overwriteExisting: true,
+  };
+}
+
+function findWebhookEventEnum(enums: Enum[]): Enum | null {
+  return (
+    enums.find((enumDef) => enumDef.name === 'CreateWebhookEndpointEvents') ??
+    enums.find(
+      (enumDef) =>
+        isWebhookEventEnumName(enumDef.name) &&
+        enumDef.values.length > 0 &&
+        enumDef.values.every((value) => typeof value.value === 'string' && value.value.includes('.')),
+    ) ??
+    null
+  );
+}
+
+function isWebhookEventEnumName(name: string): boolean {
+  const normalized = name.toLowerCase();
+  return normalized.includes('webhook') && normalized.includes('event');
+}
+
+function uniqueEventConstantName(value: string, usedNames: Set<string>): string {
+  const base = className(value);
+  if (!usedNames.has(base)) return base;
+
+  let suffix = 2;
+  while (usedNames.has(`${base}${suffix}`)) suffix++;
+  return `${base}${suffix}`;
+}
+
+function escapeGoString(value: string): string {
+  return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+
 export function assignEnumsToServices(enums: Enum[], services: Service[]): Map<string, string> {
   const enumToService = new Map<string, string>();
   const enumNames = new Set(enums.map((e) => e.name));

package/src/kotlin/enums.ts

@@ -41,12 +41,19 @@ export function generateEnums(enums: Enum[], _ctx: EmitterContext): GeneratedFil
 
   // Within each group, pick the shortest className as canonical.
   const aliasOf = new Map<string, string>(); // enum name → canonical enum name
+  const sharedSortEmitters = new Set<string>();
   for (const [, group] of hashGroups) {
-    if (group.length <= 1) continue;
+    if (group.length <= 1) {
+      if (group.length === 1 && isSharedSortOrderEnum(group[0])) {
+        enumCanonicalMap.set(group[0].name, 'SortOrder');
+        sharedSortEmitters.add(group[0].name);
+      }
+      continue;
+    }
     if (group.every(isSharedSortOrderEnum)) {
       const [canonical, ...rest] = [...group].sort((a, b) => a.name.localeCompare(b.name));
-      enumCanonicalMap.set(canonical.name, canonical.name);
-      for (const enumDef of rest) enumCanonicalMap.set(enumDef.name, 'SortOrder');
+      sharedSortEmitters.add(canonical.name);
+      for (const enumDef of [canonical, ...rest]) enumCanonicalMap.set(enumDef.name, 'SortOrder');
       continue;
     }
     const sorted = [...group].sort(
@@ -68,7 +75,7 @@ export function generateEnums(enums: Enum[], _ctx: EmitterContext): GeneratedFil
     const typeName = canonicalEnumTypeName(enumDef);
 
     // Non-canonical enum: emit a typealias instead of a full enum class.
-    const sharedSortEmitter = isSharedSortOrderEnum(enumDef) && enumCanonicalMap.get(enumDef.name) === enumDef.name;
+    const sharedSortEmitter = sharedSortEmitters.has(enumDef.name);
     const canonicalName = sharedSortEmitter
       ? undefined
       : (aliasOf.get(enumDef.name) ?? enumCanonicalMap.get(enumDef.name));

package/src/node/client.ts

@@ -18,9 +18,11 @@ import {
   isListWrapperModel,
   computeNonEventReachable,
 } from './utils.js';
+import { isNodeOwnedService, nodeOptions } from './options.js';
 import { resolveResourceClassName, resolveResourceDir } from './resources.js';
 import { generatedResourceInterfaceModelNames } from './models.js';
 import { assignEnumsToServices } from './enums.js';
+import { liveSurfaceInterfacePath } from './live-surface.js';
 
 export function generateClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
   const files: GeneratedFile[] = [];
@@ -129,6 +131,46 @@ function generateWorkOSClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
   };
 }
 
+function sourceFileForExportedType(ctx: EmitterContext, typeName: string): string | undefined {
+  return (
+    (ctx.apiSurface?.interfaces?.[typeName] as { sourceFile?: string } | undefined)?.sourceFile ??
+    (ctx.apiSurface?.typeAliases?.[typeName] as { sourceFile?: string } | undefined)?.sourceFile ??
+    (ctx.apiSurface?.enums?.[typeName] as { sourceFile?: string } | undefined)?.sourceFile ??
+    liveSurfaceInterfacePath(typeName)
+  );
+}
+
+function exportedNamesForSource(ctx: EmitterContext, sourceFile: string): string[] {
+  const names = new Set<string>();
+  const addNamesFromSurface = (items: Record<string, unknown> | undefined) => {
+    if (!items) return;
+    for (const [name, item] of Object.entries(items)) {
+      if ((item as { sourceFile?: string }).sourceFile === sourceFile) {
+        names.add(name);
+      }
+    }
+  };
+
+  addNamesFromSurface(ctx.apiSurface?.interfaces);
+  addNamesFromSurface(ctx.apiSurface?.typeAliases);
+  addNamesFromSurface(ctx.apiSurface?.enums);
+
+  const rootDir = ctx.targetDir ?? ctx.outputDir;
+  if (rootDir) {
+    try {
+      const content = fs.readFileSync(path.join(rootDir, sourceFile), 'utf-8');
+      for (const match of content.matchAll(/export\s+(?:interface|type|enum|class|const|function)\s+(\w+)/g)) {
+        names.add(match[1]);
+      }
+    } catch {
+      // The live source map is best-effort; apiSurface/livesurface names above
+      // are enough when the file is not readable.
+    }
+  }
+
+  return [...names];
+}
+
 /**
  * Generate per-service barrel files (interfaces/index.ts) that re-export
  * all interface and enum files for each service directory. This reduces
@@ -146,6 +188,19 @@ function generateServiceBarrels(spec: ApiSpec, ctx: EmitterContext): GeneratedFi
   // from one file and a domain type from another).
   const dirExports = new Map<string, string[]>();
   const dirSymbols = new Map<string, Set<string>>();
+  const ownedDirNames = new Set<string>();
+  for (const service of spec.services) {
+    if (isNodeOwnedService(ctx, service.name)) {
+      const dir = resolveDir(service.name);
+      ownedDirNames.add(dir);
+      // Ensure owned directories always get a barrel entry, even if no
+      // model interfaces are generated (hand-written files still need it).
+      if (!dirExports.has(dir)) {
+        dirExports.set(dir, []);
+        if (!dirSymbols.has(dir)) dirSymbols.set(dir, new Set());
+      }
+    }
+  }
 
   // Pre-seed dirSymbols with names already exported by existing interface files.
   // When the existing SDK has an interface file in a directory that already
@@ -160,6 +215,7 @@ function generateServiceBarrels(spec: ApiSpec, ctx: EmitterContext): GeneratedFi
     const match = sourceFile.match(/^src\/([^/]+)\/interfaces\/(.+)\.ts$/);
     if (!match) return;
     const dirName = match[1];
+    if (ownedDirNames.has(dirName)) return;
     const fileStem = match[2];
     if (!dirSymbols.has(dirName)) dirSymbols.set(dirName, new Set());
     dirSymbols.get(dirName)!.add(name);
@@ -260,14 +316,82 @@ function generateServiceBarrels(spec: ApiSpec, ctx: EmitterContext): GeneratedFi
     dirExports.get(dirName)!.push(`export * from './${fileName(enumDef.name)}.interface';`);
   }
 
+  const overrideWildcardSources = new Set<string>();
+  const overrideNamedExports = new Set<string>();
+  const addOverrideTypeExport = (typeName: string | undefined) => {
+    if (!typeName) return;
+    const sourceFile = sourceFileForExportedType(ctx, typeName);
+    if (!sourceFile) return;
+    const match = sourceFile?.match(/^src\/([^/]+)\/interfaces\/(.+)\.ts$/);
+    if (!match) return;
+    const dirName = match[1];
+    const stem = match[2].replace(/\.ts$/, '');
+    if (!dirExports.has(dirName)) {
+      dirExports.set(dirName, []);
+      if (!dirSymbols.has(dirName)) {
+        dirSymbols.set(dirName, new Set());
+      }
+    }
+    const symbols = dirSymbols.get(dirName)!;
+    const sourceKey = `${dirName}/${stem}`;
+    if (overrideWildcardSources.has(sourceKey)) return;
+
+    const sourceNames = exportedNamesForSource(ctx, sourceFile);
+    const hasConflictingNeighbor = sourceNames.some((name) => name !== typeName && globalExistingSymbols.has(name));
+    if (hasConflictingNeighbor) {
+      const exportKey = `${sourceKey}:${typeName}`;
+      if (overrideNamedExports.has(exportKey)) return;
+      dirExports.get(dirName)!.push(`export type { ${typeName} } from './${stem}';`);
+      overrideNamedExports.add(exportKey);
+      symbols.add(typeName);
+      globalExistingSymbols.add(typeName);
+      return;
+    }
+
+    dirExports.get(dirName)!.push(`export * from './${stem}';`);
+    overrideWildcardSources.add(sourceKey);
+    const namesToRegister = sourceNames.length > 0 ? sourceNames : [typeName];
+    for (const name of namesToRegister) {
+      symbols.add(name);
+      globalExistingSymbols.add(name);
+    }
+  };
+
+  for (const override of Object.values(nodeOptions(ctx).operationOverrides ?? {})) {
+    addOverrideTypeExport(override.optionsType);
+    for (const typeName of override.returnTypeImports ?? []) {
+      addOverrideTypeExport(typeName);
+    }
+  }
+
+  const generatedOptionExports = (ctx as any)._nodeGeneratedOptionInterfaceExports as
+    | Map<string, Array<{ stem: string; typeName: string }>>
+    | undefined;
+  for (const [dirName, options] of generatedOptionExports ?? []) {
+    if (!dirExports.has(dirName)) {
+      dirExports.set(dirName, []);
+      if (!dirSymbols.has(dirName)) {
+        dirSymbols.set(dirName, new Set());
+      }
+    }
+    const symbols = dirSymbols.get(dirName)!;
+    for (const { stem, typeName } of options) {
+      if (globalExistingSymbols.has(typeName)) continue;
+      symbols.add(typeName);
+      globalExistingSymbols.add(typeName);
+      dirExports.get(dirName)!.push(`export * from './${stem}';`);
+    }
+  }
+
   for (const [dirName, exports] of dirExports) {
     const exportSet = new Set(exports);
+    const isDirOwned = ownedDirNames.has(dirName);
 
     // 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) {
+    if (ctx.apiSurface && !isDirOwned) {
       const addBaselineExports = (items: Record<string, any> | undefined) => {
         if (!items) return;
         for (const item of Object.values(items)) {
@@ -288,7 +412,7 @@ function generateServiceBarrels(spec: ApiSpec, ctx: EmitterContext): GeneratedFi
       // corresponding file still exists on disk.  This prevents dropping
       // hand-written types (e.g., Factor in multi-factor-auth) when a
       // generated model in the same file causes a symbol collision.
-      if (ctx.targetDir) {
+      if (ctx.targetDir && !isDirOwned) {
         const interfacesDir = path.join(ctx.targetDir, 'src', dirName, 'interfaces');
         try {
           const barrelPath = path.join(interfacesDir, 'index.ts');
@@ -349,6 +473,38 @@ function generateServiceBarrels(spec: ApiSpec, ctx: EmitterContext): GeneratedFi
       }
     }
 
+    // For owned directories, scan the interfaces directory for hand-written
+    // files that still need to be in the barrel (e.g., options interfaces
+    // preserved from the baseline).
+    const ownedScanRoot = ctx.targetDir ?? ctx.outputDir;
+    if (ownedScanRoot && isDirOwned) {
+      const interfacesDir = path.join(ownedScanRoot, '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;
+          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]);
+          }
+          const hasCollision = exportedNames.some((name) => globalExistingSymbols.has(name));
+          if (hasCollision) continue;
+          for (const name of exportedNames) {
+            symbols.add(name);
+            globalExistingSymbols.add(name);
+          }
+          exportSet.add(exportLine);
+        }
+      } catch {
+        // Directory doesn't exist in target
+      }
+    }
+
     // Deduplicate and sort
     const uniqueExports = [...exportSet];
     uniqueExports.sort();

package/src/node/discriminated-models.ts

@@ -69,6 +69,8 @@ interface DiscriminatedShape {
   discriminatorProperty: string;
   /** Field name in domain (camelCase). */
   discriminatorPropertyDomain: string;
+  /** Description from the OpenAPI spec, if present. */
+  discriminatorDescription?: string;
   variants: VariantSpec[];
 }
 
@@ -133,11 +135,14 @@ export function detectDiscriminatedShape(
 
   const baseFields = baseObject ? collectObjectFields(baseObject, modelName) : [];
 
+  const discriminatorDescription = flattenedVariants[0].alwaysProperties.get(discProp)?.description;
+
   return {
     modelName,
     baseFields,
     discriminatorProperty: discProp,
     discriminatorPropertyDomain: toCamelCase(discProp),
+    discriminatorDescription,
     variants,
   };
 }
@@ -451,6 +456,8 @@ function resolveRef(schema: RawSchema, rawSchemas: Record<string, RawSchema>): R
 export interface DiscriminatedPlan {
   shape: DiscriminatedShape;
   modelDir: string;
+  /** Maps raw spec schema names to their resolved service directories. */
+  depDirMap: Map<string, string>;
 }
 
 export function planDiscriminatedModels(models: Model[], ctx: EmitterContext): Map<string, DiscriminatedPlan> {
@@ -459,11 +466,47 @@ export function planDiscriminatedModels(models: Model[], ctx: EmitterContext): M
   if (!spec?.components?.schemas) return plans;
   const rawSchemas = spec.components.schemas as Record<string, RawSchema>;
   const { modelToService, resolveDir } = createServiceDirResolver(models, ctx.spec.services, ctx);
+
+  // Build a lookup from IR model names to their resolved service directories.
+  const irModelDir = new Map<string, string>();
+  for (const model of models) {
+    irModelDir.set(model.name, resolveDir(modelToService.get(model.name)));
+  }
+
+  // Map raw spec schema names to service directories so discriminated model
+  // imports can point to the correct cross-service path. Raw names may differ
+  // from IR names due to schemaNameTransform (e.g. Dto stripping).
+  const depDirMap = new Map<string, string>();
+  for (const rawName of Object.keys(rawSchemas)) {
+    if (irModelDir.has(rawName)) {
+      depDirMap.set(rawName, irModelDir.get(rawName)!);
+      continue;
+    }
+    const stripped = rawName.replace(/Dto/g, '').replace(/DTO/g, '').replace(/Json$/, '');
+    if (stripped !== rawName && irModelDir.has(stripped)) {
+      depDirMap.set(rawName, irModelDir.get(stripped)!);
+    }
+  }
+
   for (const model of models) {
     const shape = detectDiscriminatedShape(model.name, rawSchemas);
     if (!shape) continue;
+    // Skip models whose variant field dependencies can't all be resolved to
+    // existing interface files. EventSchema, for instance, references models
+    // from many services that may not have generated files yet.
+    const allDeps = new Set<string>();
+    for (const field of shape.baseFields) {
+      for (const d of field.modelDeps) allDeps.add(d);
+    }
+    for (const variant of shape.variants) {
+      for (const field of variant.fields) {
+        for (const d of field.modelDeps) allDeps.add(d);
+      }
+    }
+    const hasUnresolvableDeps = [...allDeps].some((dep) => !depDirMap.has(dep) && !irModelDir.has(dep));
+    if (hasUnresolvableDeps) continue;
     const modelDir = resolveDir(modelToService.get(model.name));
-    plans.set(model.name, { shape, modelDir });
+    plans.set(model.name, { shape, modelDir, depDirMap });
   }
   return plans;
 }
@@ -521,12 +564,20 @@ function buildInterfaceFile(plan: DiscriminatedPlan, _ctx: EmitterContext): Gene
 function buildInterfaceBody(name: string, shape: DiscriminatedShape, variant: VariantSpec, isWire: boolean): string[] {
   const lines: string[] = [];
   lines.push(`export interface ${name} {`);
-  // Base fields
+  // Variant fields override base fields when both define the same property
+  // (variants have narrower types, e.g. `event: 'foo'` vs base `event: string`).
+  // The discriminator is also emitted separately as a const literal below.
+  const variantFieldNames = new Set(variant.fields.map((f) => f.name));
   for (const field of shape.baseFields) {
+    if (variantFieldNames.has(field.name)) continue;
+    if (field.name === shape.discriminatorProperty) continue;
     pushFieldLine(lines, field, isWire);
   }
   // Discriminator (typed as the variant's const value)
   const discKey = isWire ? shape.discriminatorProperty : shape.discriminatorPropertyDomain;
+  if (shape.discriminatorDescription) {
+    lines.push(`  /** ${shape.discriminatorDescription} */`);
+  }
   lines.push(`  ${discKey}: '${variant.discriminatorValue}';`);
   // Variant-specific fields
   for (const field of variant.fields) {
@@ -561,31 +612,24 @@ function collectImports(plan: DiscriminatedPlan): ImportSpec[] {
       for (const d of field.modelDeps) deps.add(d);
     }
   }
-  // Group by directory — all deps under the same modelDir get one import.
-  // We assume all deps live in the same service for now (same dir as this
-  // model). Cross-service imports would need ctx.spec.services lookups; the
-  // current discriminated-shape cases (ConnectApplication) are all
-  // intra-service.
-  const symbols: string[] = [];
+  const result: ImportSpec[] = [];
   for (const dep of [...deps].sort()) {
     const domain = toPascalCase(dep);
-    symbols.push(domain);
     const wire = wireInterfaceName(domain);
-    if (wire !== domain) symbols.push(wire);
-  }
-  if (symbols.length === 0) return [];
-  // Single import block from sibling files in the same interfaces directory.
-  return symbols
-    .map((sym) => {
-      const fname = fileName(toSnakeFromPascal(sym.replace(/Response$/, '')));
-      return { path: `./${fname}.interface`, symbols: [sym] };
-    })
-    .reduce((acc, cur) => {
-      const existing = acc.find((a) => a.path === cur.path);
-      if (existing) existing.symbols.push(...cur.symbols);
-      else acc.push(cur);
-      return acc;
-    }, [] as ImportSpec[]);
+    const symbols = wire !== domain ? [domain, wire] : [domain];
+    const depDir = plan.depDirMap.get(dep);
+    const baseName = fileName(toSnakeFromPascal(domain));
+    let importPath: string;
+    if (!depDir || depDir === plan.modelDir) {
+      importPath = `./${baseName}.interface`;
+    } else {
+      importPath = `../../${depDir}/interfaces/${baseName}.interface`;
+    }
+    const existing = result.find((a) => a.path === importPath);
+    if (existing) existing.symbols.push(...symbols);
+    else result.push({ path: importPath, symbols });
+  }
+  return result;
 }
 
 function toSnakeFromPascal(s: string): string {