@workos/oagen-emitters 0.0.1 → 0.2.1

package/dist/index.js

@@ -1,2158 +0,0 @@
-// src/node/models.ts
-import { walkTypeRef as walkTypeRef2 } from "@workos/oagen";
-
-// src/node/type-map.ts
-import { mapTypeRef as irMapTypeRef } from "@workos/oagen";
-
-// src/node/naming.ts
-import { toPascalCase, toCamelCase, toKebabCase, toSnakeCase } from "@workos/oagen";
-function fileName(name) {
-  return toKebabCase(name);
-}
-function fieldName(name) {
-  return toCamelCase(name);
-}
-function wireFieldName(name) {
-  return toSnakeCase(name);
-}
-function wireInterfaceName(domainName) {
-  return domainName.endsWith("Response") ? `${domainName}Wire` : `${domainName}Response`;
-}
-function serviceDirName(name) {
-  return toKebabCase(name);
-}
-function servicePropertyName(name) {
-  return toCamelCase(name);
-}
-function resolveServiceName(service, ctx) {
-  return resolveClassName(service, ctx);
-}
-function buildServiceNameMap(services, ctx) {
-  const map = /* @__PURE__ */ new Map();
-  for (const service of services) {
-    map.set(service.name, resolveServiceName(service, ctx));
-  }
-  return map;
-}
-function resolveMethodName(op, _service, ctx) {
-  const httpKey = `${op.httpMethod.toUpperCase()} ${op.path}`;
-  const existing = ctx.overlayLookup?.methodByOperation?.get(httpKey);
-  if (existing) return existing.methodName;
-  return toCamelCase(op.name);
-}
-function resolveClassName(service, ctx) {
-  if (ctx.overlayLookup?.methodByOperation) {
-    for (const op of service.operations) {
-      const httpKey = `${op.httpMethod.toUpperCase()} ${op.path}`;
-      const existing = ctx.overlayLookup.methodByOperation.get(httpKey);
-      if (existing) return existing.className;
-    }
-  }
-  return toPascalCase(service.name);
-}
-function resolveInterfaceName(name, ctx) {
-  const existing = ctx.overlayLookup?.interfaceByName?.get(name);
-  if (existing) return existing;
-  return toPascalCase(name);
-}
-
-// src/node/type-map.ts
-function mapTypeRef(ref) {
-  return irMapTypeRef(ref, {
-    primitive: mapPrimitive,
-    array: (_r, items) => `${parenthesizeUnion(items)}[]`,
-    model: (r) => r.name,
-    enum: (r) => r.name,
-    union: (_r, variants) => variants.join(" | "),
-    nullable: (_r, inner) => `${inner} | null`,
-    literal: (r) => typeof r.value === "string" ? `'${r.value}'` : String(r.value),
-    map: (_r, value) => `Record<string, ${value}>`
-  });
-}
-function mapWireTypeRef(ref) {
-  return irMapTypeRef(ref, {
-    primitive: mapPrimitive,
-    array: (_r, items) => `${parenthesizeUnion(items)}[]`,
-    model: (r) => wireInterfaceName(r.name),
-    enum: (r) => r.name,
-    union: (_r, variants) => variants.join(" | "),
-    nullable: (_r, inner) => `${inner} | null`,
-    literal: (r) => typeof r.value === "string" ? `'${r.value}'` : String(r.value),
-    map: (_r, value) => `Record<string, ${value}>`
-  });
-}
-function mapPrimitive(ref) {
-  switch (ref.type) {
-    case "string":
-      return "string";
-    case "integer":
-    case "number":
-      return "number";
-    case "boolean":
-      return "boolean";
-    case "unknown":
-      return "any";
-  }
-}
-function parenthesizeUnion(type) {
-  return type.includes(" | ") ? `(${type})` : type;
-}
-
-// src/node/utils.ts
-import { walkTypeRef } from "@workos/oagen";
-function collectModelRefs(ref) {
-  const names = [];
-  walkTypeRef(ref, { model: (r) => names.push(r.name) });
-  return names;
-}
-function collectEnumRefs(ref) {
-  const names = [];
-  walkTypeRef(ref, { enum: (r) => names.push(r.name) });
-  return names;
-}
-function assignModelsToServices(models, services) {
-  const modelToService = /* @__PURE__ */ new Map();
-  const modelNames = new Set(models.map((m) => m.name));
-  for (const service of services) {
-    const referencedModels = /* @__PURE__ */ new Set();
-    for (const op of service.operations) {
-      if (op.requestBody) {
-        for (const name of collectModelRefs(op.requestBody)) {
-          referencedModels.add(name);
-        }
-      }
-      for (const name of collectModelRefs(op.response)) {
-        referencedModels.add(name);
-      }
-      for (const param of [...op.pathParams, ...op.queryParams, ...op.headerParams]) {
-        for (const name of collectModelRefs(param.type)) {
-          referencedModels.add(name);
-        }
-      }
-      if (op.pagination) {
-        for (const name of collectModelRefs(op.pagination.itemType)) {
-          referencedModels.add(name);
-        }
-      }
-    }
-    const toVisit = [...referencedModels];
-    while (toVisit.length > 0) {
-      const name = toVisit.pop();
-      const model = models.find((m) => m.name === name);
-      if (!model) continue;
-      for (const field of model.fields) {
-        for (const ref of collectModelRefs(field.type)) {
-          if (!referencedModels.has(ref) && modelNames.has(ref)) {
-            referencedModels.add(ref);
-            toVisit.push(ref);
-          }
-        }
-      }
-    }
-    for (const name of referencedModels) {
-      if (!modelToService.has(name)) {
-        modelToService.set(name, service.name);
-      }
-    }
-  }
-  return modelToService;
-}
-function collectFieldDependencies(model) {
-  const models = /* @__PURE__ */ new Set();
-  const enums = /* @__PURE__ */ new Set();
-  for (const field of model.fields) {
-    for (const name of collectModelRefs(field.type)) {
-      if (name !== model.name) models.add(name);
-    }
-    for (const name of collectEnumRefs(field.type)) {
-      enums.add(name);
-    }
-  }
-  return { models, enums };
-}
-function relativeImport(fromFile, toFile) {
-  const fromDir = fromFile.split("/").slice(0, -1);
-  const toFileParts = toFile.split("/");
-  const toDir = toFileParts.slice(0, -1);
-  const toFileName = toFileParts[toFileParts.length - 1];
-  let common = 0;
-  while (common < fromDir.length && common < toDir.length && fromDir[common] === toDir[common]) {
-    common++;
-  }
-  const ups = fromDir.length - common;
-  const downs = toDir.slice(common);
-  const parts = [...Array(ups).fill(".."), ...downs, toFileName];
-  let result = parts.join("/");
-  result = result.replace(/\.ts$/, "");
-  if (!result.startsWith(".")) result = "./" + result;
-  return result;
-}
-function docComment(description, indent = 0) {
-  const pad = " ".repeat(indent);
-  const descLines = description.split("\n");
-  if (descLines.length === 1) {
-    return [`${pad}/** ${descLines[0]} */`];
-  }
-  const lines = [`${pad}/**`];
-  for (const line of descLines) {
-    lines.push(line === "" ? `${pad} *` : `${pad} * ${line}`);
-  }
-  lines.push(`${pad} */`);
-  return lines;
-}
-
-// src/node/models.ts
-var BUILTINS = /* @__PURE__ */ new Set([
-  "Record",
-  "Promise",
-  "Array",
-  "Map",
-  "Set",
-  "Date",
-  "string",
-  "number",
-  "boolean",
-  "void",
-  "null",
-  "undefined",
-  "any",
-  "never",
-  "unknown",
-  "true",
-  "false"
-]);
-function generateModels(models, ctx) {
-  if (models.length === 0) return [];
-  const modelToService = assignModelsToServices(models, ctx.spec.services);
-  const serviceNameMap = buildServiceNameMap(ctx.spec.services, ctx);
-  const resolveDir = (irService) => irService ? serviceDirName(serviceNameMap.get(irService) ?? irService) : "common";
-  const files = [];
-  for (const model of models) {
-    const service = modelToService.get(model.name);
-    const dirName = resolveDir(service);
-    const domainName = resolveInterfaceName(model.name, ctx);
-    const responseName = wireInterfaceName(domainName);
-    const deps = collectFieldDependencies(model);
-    const lines = [];
-    const baselineDomain = ctx.apiSurface?.interfaces?.[domainName];
-    const baselineResponse = ctx.apiSurface?.interfaces?.[responseName];
-    const importableNames = /* @__PURE__ */ new Set();
-    importableNames.add(domainName);
-    importableNames.add(responseName);
-    for (const dep of deps.models) {
-      const depName = resolveInterfaceName(dep, ctx);
-      importableNames.add(depName);
-      importableNames.add(wireInterfaceName(depName));
-    }
-    for (const dep of deps.enums) {
-      importableNames.add(dep);
-    }
-    const typeDecls = /* @__PURE__ */ new Map();
-    const crossServiceImports = /* @__PURE__ */ new Map();
-    const enumToService = assignEnumsToServices(ctx.spec.enums, ctx.spec.services);
-    const resolvedEnumNames = /* @__PURE__ */ new Map();
-    for (const e of ctx.spec.enums) {
-      resolvedEnumNames.set(resolveInterfaceName(e.name, ctx), e.name);
-    }
-    for (const field of model.fields) {
-      const baselineFields = [
-        baselineDomain?.fields?.[fieldName(field.name)],
-        baselineResponse?.fields?.[wireFieldName(field.name)]
-      ].filter(Boolean);
-      for (const bf of baselineFields) {
-        const names = bf.type.match(/\b[A-Z][a-zA-Z0-9]*\b/g);
-        if (!names) continue;
-        for (const name of names) {
-          if (BUILTINS.has(name)) continue;
-          if (importableNames.has(name)) continue;
-          if (typeDecls.has(name)) continue;
-          if (crossServiceImports.has(name)) continue;
-          const irEnumName = resolvedEnumNames.get(name);
-          if (irEnumName && !deps.enums.has(irEnumName)) {
-            const eService = enumToService.get(irEnumName);
-            const eDir = resolveDir(eService);
-            const relPath = eDir === dirName ? `./${fileName(irEnumName)}.interface` : `../../${eDir}/interfaces/${fileName(irEnumName)}.interface`;
-            crossServiceImports.set(name, { name, relPath });
-            importableNames.add(name);
-            continue;
-          }
-          const candidates = [...importableNames].filter((n) => n.endsWith(name) && n !== name);
-          if (candidates.length === 1) {
-            typeDecls.set(name, candidates[0]);
-            importableNames.add(name);
-          } else {
-            const innerType = field.type.kind === "nullable" ? field.type.inner : field.type;
-            const typeExpr = mapTypeRef(innerType);
-            typeDecls.set(name, typeExpr);
-            importableNames.add(name);
-          }
-        }
-      }
-    }
-    for (const dep of deps.models) {
-      const depName = resolveInterfaceName(dep, ctx);
-      const depService = modelToService.get(dep);
-      const depDir = resolveDir(depService);
-      const relPath = depDir === dirName ? `./${fileName(dep)}.interface` : `../../${depDir}/interfaces/${fileName(dep)}.interface`;
-      lines.push(`import type { ${depName}, ${wireInterfaceName(depName)} } from '${relPath}';`);
-    }
-    for (const dep of deps.enums) {
-      const depService = enumToService.get(dep);
-      const depDir = resolveDir(depService);
-      const relPath = depDir === dirName ? `./${fileName(dep)}.interface` : `../../${depDir}/interfaces/${fileName(dep)}.interface`;
-      lines.push(`import type { ${dep} } from '${relPath}';`);
-    }
-    for (const [, imp] of crossServiceImports) {
-      lines.push(`import type { ${imp.name} } from '${imp.relPath}';`);
-    }
-    if (lines.length > 0) lines.push("");
-    for (const [alias, typeExpr] of typeDecls) {
-      lines.push(`type ${alias} = ${typeExpr};`);
-    }
-    if (typeDecls.size > 0) lines.push("");
-    const typeParams = renderTypeParams(model);
-    const seenDomainFields = /* @__PURE__ */ new Set();
-    if (model.description) {
-      lines.push(...docComment(model.description));
-    }
-    lines.push(`export interface ${domainName}${typeParams} {`);
-    for (const field of model.fields) {
-      const domainFieldName = fieldName(field.name);
-      if (seenDomainFields.has(domainFieldName)) continue;
-      seenDomainFields.add(domainFieldName);
-      if (field.description || field.deprecated) {
-        const parts = [];
-        if (field.description) parts.push(field.description);
-        if (field.deprecated) parts.push("@deprecated");
-        lines.push(...docComment(parts.join("\n"), 2));
-      }
-      const baselineField = baselineDomain?.fields?.[domainFieldName];
-      const domainWireField = wireFieldName(field.name);
-      const responseBaselineField = baselineResponse?.fields?.[domainWireField];
-      const domainResponseOptionalMismatch = baselineField && !baselineField.optional && responseBaselineField && responseBaselineField.optional;
-      if (baselineField && !domainResponseOptionalMismatch && baselineTypeResolvable(baselineField.type, importableNames) && baselineFieldCompatible(baselineField, field)) {
-        const opt = baselineField.optional ? "?" : "";
-        lines.push(`  ${domainFieldName}${opt}: ${baselineField.type};`);
-      } else {
-        const opt = !field.required ? "?" : "";
-        lines.push(`  ${domainFieldName}${opt}: ${mapTypeRef(field.type)};`);
-      }
-    }
-    lines.push("}");
-    lines.push("");
-    const seenWireFields = /* @__PURE__ */ new Set();
-    lines.push(`export interface ${responseName}${typeParams} {`);
-    for (const field of model.fields) {
-      const wireField = wireFieldName(field.name);
-      if (seenWireFields.has(wireField)) continue;
-      seenWireFields.add(wireField);
-      const baselineField = baselineResponse?.fields?.[wireField];
-      if (baselineField && baselineTypeResolvable(baselineField.type, importableNames) && baselineFieldCompatible(baselineField, field)) {
-        const opt = baselineField.optional ? "?" : "";
-        lines.push(`  ${wireField}${opt}: ${baselineField.type};`);
-      } else {
-        const opt = !field.required ? "?" : "";
-        lines.push(`  ${wireField}${opt}: ${mapWireTypeRef(field.type)};`);
-      }
-    }
-    lines.push("}");
-    files.push({
-      path: `src/${dirName}/interfaces/${fileName(model.name)}.interface.ts`,
-      content: lines.join("\n"),
-      skipIfExists: true
-    });
-  }
-  return files;
-}
-function baselineTypeResolvable(typeStr, importableNames) {
-  const matches = typeStr.match(/\b[A-Z][a-zA-Z0-9]*\b/g);
-  if (!matches) return true;
-  for (const name of matches) {
-    if (BUILTINS.has(name)) continue;
-    if (importableNames.has(name)) continue;
-    return false;
-  }
-  return true;
-}
-function baselineFieldCompatible(baselineField, irField) {
-  const irNullable = irField.type.kind === "nullable";
-  const baselineHasNull = baselineField.type.includes("null");
-  if (irNullable && !baselineHasNull && irField.required) {
-    return false;
-  }
-  if (!irField.required && !baselineField.optional && !baselineField.type.includes("undefined")) {
-    return false;
-  }
-  return true;
-}
-function renderTypeParams(model) {
-  if (!model.typeParams?.length) return "";
-  const params = model.typeParams.map((tp) => {
-    const def = tp.default ? ` = ${mapTypeRef(tp.default)}` : "";
-    return `${tp.name}${def}`;
-  });
-  return `<${params.join(", ")}>`;
-}
-function assignEnumsToServices(enums, services) {
-  const enumToService = /* @__PURE__ */ new Map();
-  const enumNames = new Set(enums.map((e) => e.name));
-  for (const service of services) {
-    for (const op of service.operations) {
-      const refs = /* @__PURE__ */ new Set();
-      const collect = (ref) => {
-        walkTypeRef2(ref, { enum: (r) => refs.add(r.name) });
-      };
-      if (op.requestBody) collect(op.requestBody);
-      collect(op.response);
-      for (const p of [...op.pathParams, ...op.queryParams, ...op.headerParams]) {
-        collect(p.type);
-      }
-      for (const name of refs) {
-        if (enumNames.has(name) && !enumToService.has(name)) {
-          enumToService.set(name, service.name);
-        }
-      }
-    }
-  }
-  return enumToService;
-}
-
-// src/node/enums.ts
-import { walkTypeRef as walkTypeRef3 } from "@workos/oagen";
-function generateEnums(enums, ctx) {
-  if (enums.length === 0) return [];
-  const enumToService = assignEnumsToServices2(enums, ctx.spec.services);
-  const serviceNameMap = buildServiceNameMap(ctx.spec.services, ctx);
-  const resolveDir = (irService) => irService ? serviceDirName(serviceNameMap.get(irService) ?? irService) : "common";
-  const files = [];
-  for (const enumDef of enums) {
-    const service = enumToService.get(enumDef.name);
-    const dirName = resolveDir(service);
-    const baselineEnum = ctx.apiSurface?.enums?.[enumDef.name];
-    const baselineAlias = ctx.apiSurface?.typeAliases?.[enumDef.name];
-    const lines = [];
-    if (baselineEnum?.members) {
-      lines.push(`export enum ${enumDef.name} {`);
-      for (const [memberName, memberValue] of Object.entries(baselineEnum.members)) {
-        const valueStr = typeof memberValue === "string" ? `'${memberValue}'` : String(memberValue);
-        lines.push(`  ${memberName} = ${valueStr},`);
-      }
-      lines.push("}");
-    } else if (baselineAlias?.value) {
-      lines.push(`export type ${enumDef.name} = ${baselineAlias.value};`);
-    } else {
-      const values = enumDef.values;
-      lines.push(`export type ${enumDef.name} =`);
-      for (let i = 0; i < values.length; i++) {
-        const v = values[i];
-        const valueStr = typeof v.value === "string" ? `'${v.value}'` : String(v.value);
-        if (v.description || v.deprecated) {
-          const parts = [];
-          if (v.description) parts.push(v.description);
-          if (v.deprecated) parts.push("@deprecated");
-          lines.push(...docComment(parts.join("\n"), 2));
-        }
-        const suffix = i === values.length - 1 ? ";" : "";
-        lines.push(`  | ${valueStr}${suffix}`);
-      }
-    }
-    files.push({
-      path: `src/${dirName}/interfaces/${fileName(enumDef.name)}.interface.ts`,
-      content: lines.join("\n"),
-      skipIfExists: true
-    });
-  }
-  return files;
-}
-function assignEnumsToServices2(enums, services) {
-  const enumToService = /* @__PURE__ */ new Map();
-  const enumNames = new Set(enums.map((e) => e.name));
-  for (const service of services) {
-    for (const op of service.operations) {
-      const refs = /* @__PURE__ */ new Set();
-      const collect = (ref) => {
-        walkTypeRef3(ref, { enum: (r) => refs.add(r.name) });
-      };
-      if (op.requestBody) collect(op.requestBody);
-      collect(op.response);
-      for (const p of [...op.pathParams, ...op.queryParams, ...op.headerParams]) {
-        collect(p.type);
-      }
-      for (const name of refs) {
-        if (enumNames.has(name) && !enumToService.has(name)) {
-          enumToService.set(name, service.name);
-        }
-      }
-    }
-  }
-  return enumToService;
-}
-
-// src/node/serializers.ts
-function generateSerializers(models, ctx) {
-  if (models.length === 0) return [];
-  const modelToService = assignModelsToServices(models, ctx.spec.services);
-  const serviceNameMap = buildServiceNameMap(ctx.spec.services, ctx);
-  const resolveDir = (irService) => irService ? serviceDirName(serviceNameMap.get(irService) ?? irService) : "common";
-  const files = [];
-  for (const model of models) {
-    const service = modelToService.get(model.name);
-    const dirName = resolveDir(service);
-    const domainName = resolveInterfaceName(model.name, ctx);
-    const responseName = wireInterfaceName(domainName);
-    const serializerPath = `src/${dirName}/serializers/${fileName(model.name)}.serializer.ts`;
-    const nestedModelRefs = /* @__PURE__ */ new Set();
-    for (const field of model.fields) {
-      for (const ref of collectSerializedModelRefs(field.type)) {
-        if (ref !== model.name) nestedModelRefs.add(ref);
-      }
-    }
-    const lines = [];
-    const interfacePath = `src/${dirName}/interfaces/${fileName(model.name)}.interface.ts`;
-    lines.push(
-      `import type { ${domainName}, ${responseName} } from '${relativeImport(serializerPath, interfacePath)}';`
-    );
-    for (const dep of nestedModelRefs) {
-      const depService = modelToService.get(dep);
-      const depDir = resolveDir(depService);
-      const depSerializerPath = `src/${depDir}/serializers/${fileName(dep)}.serializer.ts`;
-      const depName = resolveInterfaceName(dep, ctx);
-      const imports = [`deserialize${depName}`, `serialize${depName}`];
-      lines.push(`import { ${imports.join(", ")} } from '${relativeImport(serializerPath, depSerializerPath)}';`);
-    }
-    lines.push("");
-    const seenDeserFields = /* @__PURE__ */ new Set();
-    lines.push(`export const deserialize${domainName} = (`);
-    lines.push(`  response: ${responseName},`);
-    lines.push(`): ${domainName} => ({`);
-    for (const field of model.fields) {
-      const domain = fieldName(field.name);
-      if (seenDeserFields.has(domain)) continue;
-      seenDeserFields.add(domain);
-      const wire = wireFieldName(field.name);
-      const wireAccess = `response.${wire}`;
-      const expr = deserializeExpression(field.type, wireAccess, ctx);
-      if (!field.required && expr !== wireAccess && needsNullGuard(field.type)) {
-        lines.push(`  ${domain}: ${wireAccess} != null ? ${expr} : undefined,`);
-      } else if (field.required && expr === wireAccess) {
-        const fallback = defaultForType(field.type);
-        if (fallback) {
-          lines.push(`  ${domain}: ${expr} ?? ${fallback},`);
-        } else {
-          lines.push(`  ${domain}: ${expr},`);
-        }
-      } else {
-        lines.push(`  ${domain}: ${expr},`);
-      }
-    }
-    lines.push("});");
-    lines.push("");
-    lines.push(`export const serialize${domainName} = (`);
-    lines.push(`  model: ${domainName},`);
-    lines.push(`): ${responseName} => ({`);
-    const seenSerFields = /* @__PURE__ */ new Set();
-    for (const field of model.fields) {
-      const wire = wireFieldName(field.name);
-      if (seenSerFields.has(wire)) continue;
-      seenSerFields.add(wire);
-      const domain = fieldName(field.name);
-      const domainAccess = `model.${domain}`;
-      const expr = serializeExpression(field.type, domainAccess, ctx);
-      if (!field.required && expr !== domainAccess && needsNullGuard(field.type)) {
-        lines.push(`  ${wire}: ${domainAccess} != null ? ${expr} : undefined,`);
-      } else {
-        lines.push(`  ${wire}: ${expr},`);
-      }
-    }
-    lines.push("});");
-    files.push({
-      path: serializerPath,
-      content: lines.join("\n"),
-      skipIfExists: true
-    });
-  }
-  return files;
-}
-function collectSerializedModelRefs(ref) {
-  switch (ref.kind) {
-    case "model":
-      return [ref.name];
-    case "array":
-      if (ref.items.kind === "model") return [ref.items.name];
-      return collectSerializedModelRefs(ref.items);
-    case "nullable":
-      return collectSerializedModelRefs(ref.inner);
-    case "union": {
-      const models = uniqueModelVariants(ref);
-      if (models.length === 1) return models;
-      return [];
-    }
-    case "map":
-    case "primitive":
-    case "literal":
-    case "enum":
-      return [];
-  }
-}
-function deserializeExpression(ref, wireExpr, ctx) {
-  switch (ref.kind) {
-    case "primitive":
-    case "literal":
-    case "enum":
-      return wireExpr;
-    case "model": {
-      const name = resolveInterfaceName(ref.name, ctx);
-      return `deserialize${name}(${wireExpr})`;
-    }
-    case "array":
-      if (ref.items.kind === "model") {
-        const name = resolveInterfaceName(ref.items.name, ctx);
-        return `${wireExpr}.map(deserialize${name})`;
-      }
-      return wireExpr;
-    case "nullable": {
-      const innerExpr = deserializeExpression(ref.inner, wireExpr, ctx);
-      if (innerExpr !== wireExpr) {
-        return `${wireExpr} != null ? ${innerExpr} : null`;
-      }
-      return `${wireExpr} ?? null`;
-    }
-    case "union": {
-      const deserModelVariants = uniqueModelVariants(ref);
-      if (deserModelVariants.length === 1) {
-        const name = resolveInterfaceName(deserModelVariants[0], ctx);
-        return `deserialize${name}(${wireExpr})`;
-      }
-      return wireExpr;
-    }
-    case "map":
-      return wireExpr;
-  }
-}
-function serializeExpression(ref, domainExpr, ctx) {
-  switch (ref.kind) {
-    case "primitive":
-    case "literal":
-    case "enum":
-      return domainExpr;
-    case "model": {
-      const name = resolveInterfaceName(ref.name, ctx);
-      return `serialize${name}(${domainExpr})`;
-    }
-    case "array":
-      if (ref.items.kind === "model") {
-        const name = resolveInterfaceName(ref.items.name, ctx);
-        return `${domainExpr}.map(serialize${name})`;
-      }
-      return domainExpr;
-    case "nullable": {
-      const innerExpr = serializeExpression(ref.inner, domainExpr, ctx);
-      if (innerExpr !== domainExpr) {
-        return `${domainExpr} != null ? ${innerExpr} : null`;
-      }
-      return domainExpr;
-    }
-    case "union": {
-      const serModelVariants = uniqueModelVariants(ref);
-      if (serModelVariants.length === 1) {
-        const name = resolveInterfaceName(serModelVariants[0], ctx);
-        return `serialize${name}(${domainExpr})`;
-      }
-      return domainExpr;
-    }
-    case "map":
-      return domainExpr;
-  }
-}
-function uniqueModelVariants(ref) {
-  const modelNames = /* @__PURE__ */ new Set();
-  for (const v of ref.variants) {
-    if (v.kind === "model") modelNames.add(v.name);
-  }
-  return [...modelNames];
-}
-function needsNullGuard(ref) {
-  switch (ref.kind) {
-    case "model":
-      return true;
-    case "array":
-      return ref.items.kind === "model";
-    case "nullable":
-      return needsNullGuard(ref.inner);
-    case "union":
-      return uniqueModelVariants(ref).length === 1;
-    default:
-      return false;
-  }
-}
-function defaultForType(ref) {
-  switch (ref.kind) {
-    case "map":
-      return "{}";
-    case "primitive":
-      switch (ref.type) {
-        case "boolean":
-          return "false";
-        case "string":
-          return "''";
-        case "integer":
-        case "number":
-          return "0";
-        default:
-          return null;
-      }
-    case "array":
-      return "[]";
-    default:
-      return null;
-  }
-}
-
-// src/node/resources.ts
-import { planOperation, toPascalCase as toPascalCase2 } from "@workos/oagen";
-function generateResources(services, ctx) {
-  if (services.length === 0) return [];
-  return services.map((service) => generateResourceClass(service, ctx));
-}
-function generateResourceClass(service, ctx) {
-  const resolvedName = resolveServiceName(service, ctx);
-  const serviceDir = serviceDirName(resolvedName);
-  const serviceClass = resolvedName;
-  const resourcePath = `src/${serviceDir}/${fileName(resolvedName)}.ts`;
-  const plans = service.operations.map((op) => ({
-    op,
-    plan: planOperation(op),
-    method: resolveMethodName(op, service, ctx)
-  }));
-  const hasPaginated = plans.some((p) => p.plan.isPaginated);
-  const responseModels = /* @__PURE__ */ new Set();
-  const requestModels = /* @__PURE__ */ new Set();
-  for (const { op, plan } of plans) {
-    if (plan.responseModelName) responseModels.add(plan.responseModelName);
-    if (op.requestBody) {
-      for (const name of collectModelRefs(op.requestBody)) {
-        requestModels.add(name);
-      }
-    }
-  }
-  const allModels = /* @__PURE__ */ new Set([...responseModels, ...requestModels]);
-  const lines = [];
-  lines.push("import type { WorkOS } from '../workos';");
-  if (hasPaginated) {
-    lines.push("import type { PaginationOptions } from '../common/interfaces/pagination-options.interface';");
-    lines.push("import { AutoPaginatable } from '../common/utils/pagination';");
-    lines.push("import { fetchAndDeserialize } from '../common/utils/fetch-and-deserialize';");
-  }
-  const hasIdempotentPost = plans.some((p) => p.plan.isIdempotentPost);
-  if (hasIdempotentPost) {
-    lines.push("import type { PostOptions } from '../common/interfaces/post-options.interface';");
-  }
-  const modelToService = assignModelsToServices(ctx.spec.models, ctx.spec.services);
-  const serviceNameMap = buildServiceNameMap(ctx.spec.services, ctx);
-  const resolveDir = (irService) => irService ? serviceDirName(serviceNameMap.get(irService) ?? irService) : "common";
-  for (const name of allModels) {
-    const resolved = resolveInterfaceName(name, ctx);
-    const modelDir = modelToService.get(name);
-    const modelServiceDir = resolveDir(modelDir);
-    const relPath = modelServiceDir === serviceDir ? `./interfaces/${fileName(name)}.interface` : `../${modelServiceDir}/interfaces/${fileName(name)}.interface`;
-    lines.push(`import type { ${resolved}, ${wireInterfaceName(resolved)} } from '${relPath}';`);
-  }
-  for (const name of responseModels) {
-    const resolved = resolveInterfaceName(name, ctx);
-    const modelDir = modelToService.get(name);
-    const modelServiceDir = resolveDir(modelDir);
-    const relPath = modelServiceDir === serviceDir ? `./serializers/${fileName(name)}.serializer` : `../${modelServiceDir}/serializers/${fileName(name)}.serializer`;
-    lines.push(`import { deserialize${resolved} } from '${relPath}';`);
-  }
-  for (const name of requestModels) {
-    const resolved = resolveInterfaceName(name, ctx);
-    const modelDir = modelToService.get(name);
-    const modelServiceDir = resolveDir(modelDir);
-    const relPath = modelServiceDir === serviceDir ? `./serializers/${fileName(name)}.serializer` : `../${modelServiceDir}/serializers/${fileName(name)}.serializer`;
-    lines.push(`import { serialize${resolved} } from '${relPath}';`);
-  }
-  lines.push("");
-  for (const { op, plan, method } of plans) {
-    if (plan.isPaginated) {
-      const extraParams = op.queryParams.filter((p) => !["limit", "before", "after", "order"].includes(p.name));
-      if (extraParams.length > 0) {
-        const optionsName = toPascalCase2(method) + "Options";
-        lines.push(`export interface ${optionsName} extends PaginationOptions {`);
-        for (const param of extraParams) {
-          const opt = !param.required ? "?" : "";
-          if (param.description || param.deprecated) {
-            const parts = [];
-            if (param.description) parts.push(param.description);
-            if (param.deprecated) parts.push("@deprecated");
-            lines.push(...docComment(parts.join("\n"), 2));
-          }
-          lines.push(`  ${fieldName(param.name)}${opt}: ${mapTypeRef(param.type)};`);
-        }
-        lines.push("}");
-        lines.push("");
-      }
-    }
-  }
-  if (service.description) {
-    lines.push(...docComment(service.description));
-  }
-  lines.push(`export class ${serviceClass} {`);
-  lines.push("  constructor(private readonly workos: WorkOS) {}");
-  for (const { op, plan, method } of plans) {
-    lines.push("");
-    lines.push(...renderMethod(op, plan, method, service, ctx));
-  }
-  lines.push("}");
-  return { path: resourcePath, content: lines.join("\n"), skipIfExists: true };
-}
-function renderMethod(op, plan, method, service, ctx) {
-  const lines = [];
-  const responseModel = plan.responseModelName ? resolveInterfaceName(plan.responseModelName, ctx) : null;
-  const interpolatedPath = op.path.replace(/\{(\w+)\}/g, (_, p) => `\${${fieldName(p)}}`);
-  const usesTemplate = interpolatedPath.includes("${");
-  const pathStr = usesTemplate ? `\`${interpolatedPath}\`` : `'${op.path}'`;
-  const docParts = [];
-  if (op.description) docParts.push(op.description);
-  for (const param of op.pathParams) {
-    if (param.description) {
-      docParts.push(`@param ${fieldName(param.name)} - ${param.description}`);
-    }
-  }
-  if (op.deprecated) docParts.push("@deprecated");
-  for (const err of op.errors) {
-    const exceptionName = statusToExceptionName(err.statusCode);
-    if (exceptionName) {
-      docParts.push(`@throws {${exceptionName}} ${err.statusCode}`);
-    }
-  }
-  if (docParts.length > 0) {
-    const allLines = [];
-    for (const part of docParts) {
-      for (const line of part.split("\n")) {
-        allLines.push(line);
-      }
-    }
-    if (allLines.length === 1) {
-      lines.push(`  /** ${allLines[0]} */`);
-    } else {
-      lines.push("  /**");
-      for (const line of allLines) {
-        lines.push(line === "" ? "   *" : `   * ${line}`);
-      }
-      lines.push("   */");
-    }
-  }
-  if (plan.isPaginated) {
-    if (!responseModel) {
-      console.warn(
-        `[oagen] Warning: Skipping paginated method "${method}" (${op.httpMethod.toUpperCase()} ${op.path}) \u2014 response has no named model. Ensure the spec uses a $ref for paginated item types.`
-      );
-      return lines;
-    }
-    renderPaginatedMethod(lines, op, plan, method, responseModel);
-  } else if (plan.isDelete) {
-    renderDeleteMethod(lines, op, plan, method, pathStr);
-  } else if (plan.hasBody && responseModel) {
-    renderBodyMethod(lines, op, plan, method, responseModel, pathStr, ctx);
-  } else if (responseModel) {
-    renderGetMethod(lines, op, plan, method, responseModel, pathStr);
-  } else {
-    renderVoidMethod(lines, op, plan, method, pathStr);
-  }
-  return lines;
-}
-function renderPaginatedMethod(lines, op, plan, method, itemType) {
-  const extraParams = op.queryParams.filter((p) => !["limit", "before", "after", "order"].includes(p.name));
-  const optionsType = extraParams.length > 0 ? toPascalCase2(method) + "Options" : "PaginationOptions";
-  const pathStr = buildPathStr(op);
-  lines.push(`  async ${method}(options?: ${optionsType}): Promise<AutoPaginatable<${itemType}, ${optionsType}>> {`);
-  lines.push("    return new AutoPaginatable(");
-  lines.push(`      await fetchAndDeserialize<${wireInterfaceName(itemType)}, ${itemType}>(`);
-  lines.push("        this.workos,");
-  lines.push(`        ${pathStr},`);
-  lines.push(`        deserialize${itemType},`);
-  lines.push("        options,");
-  lines.push("      ),");
-  lines.push("      (params) =>");
-  lines.push(`        fetchAndDeserialize<${wireInterfaceName(itemType)}, ${itemType}>(`);
-  lines.push("          this.workos,");
-  lines.push(`          ${pathStr},`);
-  lines.push(`          deserialize${itemType},`);
-  lines.push("          params,");
-  lines.push("        ),");
-  lines.push("      options,");
-  lines.push("    );");
-  lines.push("  }");
-}
-function renderDeleteMethod(lines, op, plan, method, pathStr) {
-  const params = buildPathParams(op);
-  lines.push(`  async ${method}(${params}): Promise<void> {`);
-  lines.push(`    await this.workos.delete(${pathStr});`);
-  lines.push("  }");
-}
-function renderBodyMethod(lines, op, plan, method, responseModel, pathStr, ctx) {
-  const requestBodyModel = extractRequestBodyModelName(op);
-  const requestType = requestBodyModel ? resolveInterfaceName(requestBodyModel, ctx) : "any";
-  const paramParts = [];
-  for (const param of op.pathParams) {
-    paramParts.push(`${fieldName(param.name)}: ${mapTypeRef(param.type)}`);
-  }
-  paramParts.push(`payload: ${requestType}`);
-  if (plan.isIdempotentPost) {
-    paramParts.push("requestOptions: PostOptions = {}");
-  }
-  const paramsStr = paramParts.join(", ");
-  const bodyExpr = requestBodyModel && requestType !== "any" ? `serialize${requestType}(payload)` : "payload";
-  lines.push(`  async ${method}(${paramsStr}): Promise<${responseModel}> {`);
-  if (plan.isIdempotentPost) {
-    lines.push(`    const { data } = await this.workos.${op.httpMethod}<${wireInterfaceName(responseModel)}>(`);
-    lines.push(`      ${pathStr},`);
-    lines.push(`      ${bodyExpr},`);
-    lines.push("      requestOptions,");
-    lines.push("    );");
-  } else {
-    lines.push(`    const { data } = await this.workos.${op.httpMethod}<${wireInterfaceName(responseModel)}>(`);
-    lines.push(`      ${pathStr},`);
-    lines.push(`      ${bodyExpr},`);
-    lines.push("    );");
-  }
-  lines.push(`    return deserialize${responseModel}(data);`);
-  lines.push("  }");
-}
-function renderGetMethod(lines, op, plan, method, responseModel, pathStr) {
-  const params = buildPathParams(op);
-  const hasQuery = op.queryParams.length > 0 && !plan.isPaginated;
-  const allParams = hasQuery ? params ? `${params}, options?: Record<string, any>` : "options?: Record<string, any>" : params;
-  lines.push(`  async ${method}(${allParams}): Promise<${responseModel}> {`);
-  if (hasQuery) {
-    lines.push(
-      `    const { data } = await this.workos.${op.httpMethod}<${wireInterfaceName(responseModel)}>(${pathStr}, {`
-    );
-    lines.push("      query: options,");
-    lines.push("    });");
-  } else {
-    lines.push(
-      `    const { data } = await this.workos.${op.httpMethod}<${wireInterfaceName(responseModel)}>(${pathStr});`
-    );
-  }
-  lines.push(`    return deserialize${responseModel}(data);`);
-  lines.push("  }");
-}
-function renderVoidMethod(lines, op, plan, method, pathStr) {
-  const params = buildPathParams(op);
-  const allParams = plan.hasBody ? params ? `${params}, payload: any` : "payload: any" : params;
-  lines.push(`  async ${method}(${allParams}): Promise<void> {`);
-  if (plan.hasBody) {
-    lines.push(`    await this.workos.${op.httpMethod}(${pathStr}, payload);`);
-  } else {
-    lines.push(`    await this.workos.${op.httpMethod}(${pathStr});`);
-  }
-  lines.push("  }");
-}
-function buildPathStr(op) {
-  const interpolated = op.path.replace(/\{(\w+)\}/g, (_, p) => `\${${fieldName(p)}}`);
-  return interpolated.includes("${") ? `\`${interpolated}\`` : `'${op.path}'`;
-}
-function buildPathParams(op) {
-  return op.pathParams.map((p) => `${fieldName(p.name)}: ${mapTypeRef(p.type)}`).join(", ");
-}
-function extractRequestBodyModelName(op) {
-  if (!op.requestBody) return null;
-  if (op.requestBody.kind === "model") return op.requestBody.name;
-  return null;
-}
-var STATUS_TO_EXCEPTION = {
-  400: "BadRequestException",
-  401: "UnauthorizedException",
-  404: "NotFoundException",
-  409: "ConflictException",
-  422: "UnprocessableEntityException",
-  429: "RateLimitExceededException"
-};
-function statusToExceptionName(statusCode) {
-  if (STATUS_TO_EXCEPTION[statusCode]) return STATUS_TO_EXCEPTION[statusCode];
-  if (statusCode >= 500) return "GenericServerException";
-  return null;
-}
-
-// src/node/client.ts
-function generateClient(spec, ctx) {
-  const files = [];
-  files.push(generateWorkOSClient(spec, ctx));
-  files.push(generateBarrel(spec, ctx));
-  files.push(generatePackageJson(ctx));
-  files.push(generateTsConfig());
-  return files;
-}
-function generateWorkOSClient(spec, ctx) {
-  const lines = [];
-  for (const service of spec.services) {
-    const resolvedName = resolveServiceName(service, ctx);
-    const serviceDir = serviceDirName(resolvedName);
-    lines.push(`import { ${resolvedName} } from './${serviceDir}/${fileName(resolvedName)}';`);
-  }
-  lines.push("import type { WorkOSOptions } from './common/interfaces/workos-options.interface';");
-  lines.push("import type { PostOptions } from './common/interfaces/post-options.interface';");
-  lines.push("import type { GetOptions } from './common/interfaces/get-options.interface';");
-  lines.push("import { NoApiKeyProvidedException } from './common/exceptions/no-api-key-provided.exception';");
-  lines.push("import { UnauthorizedException } from './common/exceptions/unauthorized.exception';");
-  lines.push("import { NotFoundException } from './common/exceptions/not-found.exception';");
-  lines.push("import { ConflictException } from './common/exceptions/conflict.exception';");
-  lines.push("import { UnprocessableEntityException } from './common/exceptions/unprocessable-entity.exception';");
-  lines.push("import { RateLimitExceededException } from './common/exceptions/rate-limit-exceeded.exception';");
-  lines.push("import { GenericServerException } from './common/exceptions/generic-server.exception';");
-  lines.push("import { BadRequestException } from './common/exceptions/bad-request.exception';");
-  lines.push("");
-  lines.push("export class WorkOS {");
-  lines.push("  readonly baseURL: string;");
-  lines.push("  readonly key: string;");
-  lines.push("  private readonly options: WorkOSOptions;");
-  lines.push("");
-  for (const service of spec.services) {
-    const resolvedName = resolveServiceName(service, ctx);
-    const propName = servicePropertyName(resolvedName);
-    lines.push(`  readonly ${propName} = new ${resolvedName}(this);`);
-  }
-  lines.push("");
-  lines.push("  constructor(keyOrOptions?: string | WorkOSOptions, maybeOptions?: WorkOSOptions) {");
-  lines.push("    if (typeof keyOrOptions === 'object') {");
-  lines.push("      this.key = keyOrOptions.apiKey ?? '';");
-  lines.push("      this.options = keyOrOptions;");
-  lines.push("    } else {");
-  lines.push("      this.key = keyOrOptions ?? '';");
-  lines.push("      this.options = maybeOptions ?? {};");
-  lines.push("    }");
-  lines.push("");
-  lines.push("    if (!this.key) {");
-  lines.push("      const envKey = typeof process !== 'undefined' ? process.env?.WORKOS_API_KEY : undefined;");
-  lines.push("      if (envKey) this.key = envKey;");
-  lines.push("    }");
-  lines.push("");
-  lines.push("    const protocol = this.options.https === false ? 'http' : 'https';");
-  lines.push("    const hostname = this.options.apiHostname ?? 'api.workos.com';");
-  lines.push("    const port = this.options.port ? `:${this.options.port}` : '';");
-  lines.push("    this.baseURL = `${protocol}://${hostname}${port}`;");
-  lines.push("  }");
-  lines.push("");
-  lines.push("  async get<Result = any>(path: string, options: GetOptions = {}): Promise<{ data: Result }> {");
-  lines.push("    this.ensureApiKey(options);");
-  lines.push("    const url = this.buildUrl(path, options.query);");
-  lines.push("    const response = await fetch(url, {");
-  lines.push("      method: 'GET',");
-  lines.push("      headers: this.buildHeaders(options),");
-  lines.push("    });");
-  lines.push("    await this.handleHttpError(response, path);");
-  lines.push("    const data = await response.json() as Result;");
-  lines.push("    return { data };");
-  lines.push("  }");
-  lines.push("");
-  lines.push(
-    "  async post<Result = any, Entity = any>(path: string, entity: Entity, options: PostOptions = {}): Promise<{ data: Result }> {"
-  );
-  lines.push("    this.ensureApiKey(options);");
-  lines.push("    const url = this.buildUrl(path, options.query);");
-  lines.push("    const response = await fetch(url, {");
-  lines.push("      method: 'POST',");
-  lines.push("      headers: this.buildHeaders(options),");
-  lines.push("      body: JSON.stringify(entity),");
-  lines.push("    });");
-  lines.push("    await this.handleHttpError(response, path);");
-  lines.push("    const data = await response.json() as Result;");
-  lines.push("    return { data };");
-  lines.push("  }");
-  lines.push("");
-  lines.push(
-    "  async put<Result = any, Entity = any>(path: string, entity: Entity, options: PostOptions = {}): Promise<{ data: Result }> {"
-  );
-  lines.push("    this.ensureApiKey(options);");
-  lines.push("    const url = this.buildUrl(path, options.query);");
-  lines.push("    const response = await fetch(url, {");
-  lines.push("      method: 'PUT',");
-  lines.push("      headers: this.buildHeaders(options),");
-  lines.push("      body: JSON.stringify(entity),");
-  lines.push("    });");
-  lines.push("    await this.handleHttpError(response, path);");
-  lines.push("    const data = await response.json() as Result;");
-  lines.push("    return { data };");
-  lines.push("  }");
-  lines.push("");
-  lines.push(
-    "  async patch<Result = any, Entity = any>(path: string, entity: Entity, options: PostOptions = {}): Promise<{ data: Result }> {"
-  );
-  lines.push("    this.ensureApiKey(options);");
-  lines.push("    const url = this.buildUrl(path, options.query);");
-  lines.push("    const response = await fetch(url, {");
-  lines.push("      method: 'PATCH',");
-  lines.push("      headers: this.buildHeaders(options),");
-  lines.push("      body: JSON.stringify(entity),");
-  lines.push("    });");
-  lines.push("    await this.handleHttpError(response, path);");
-  lines.push("    const data = await response.json() as Result;");
-  lines.push("    return { data };");
-  lines.push("  }");
-  lines.push("");
-  lines.push("  async delete(path: string, options: GetOptions = {}): Promise<void> {");
-  lines.push("    this.ensureApiKey(options);");
-  lines.push("    const url = this.buildUrl(path);");
-  lines.push("    const response = await fetch(url, {");
-  lines.push("      method: 'DELETE',");
-  lines.push("      headers: this.buildHeaders(options),");
-  lines.push("    });");
-  lines.push("    await this.handleHttpError(response, path);");
-  lines.push("  }");
-  lines.push("");
-  lines.push("  private buildUrl(path: string, query?: Record<string, any>): string {");
-  lines.push("    const url = new URL(path, this.baseURL);");
-  lines.push("    if (query) {");
-  lines.push("      for (const [key, value] of Object.entries(query)) {");
-  lines.push("        if (value !== null && value !== undefined && value !== '') {");
-  lines.push("          url.searchParams.set(key, String(value));");
-  lines.push("        }");
-  lines.push("      }");
-  lines.push("    }");
-  lines.push("    return url.toString();");
-  lines.push("  }");
-  lines.push("");
-  lines.push("  private buildHeaders(options: any = {}): Record<string, string> {");
-  lines.push("    const headers: Record<string, string> = {");
-  lines.push("      'Content-Type': 'application/json',");
-  lines.push(`      Authorization: \`Bearer \${this.key}\`,`);
-  lines.push("    };");
-  lines.push("    if (options.idempotencyKey) headers['Idempotency-Key'] = options.idempotencyKey;");
-  lines.push("    if (options.warrantToken) headers['Warrant-Token'] = options.warrantToken;");
-  lines.push("    return headers;");
-  lines.push("  }");
-  lines.push("");
-  lines.push("  private ensureApiKey(options: any = {}): void {");
-  lines.push("    if (!this.key && !options.skipApiKeyCheck) {");
-  lines.push("      throw new NoApiKeyProvidedException();");
-  lines.push("    }");
-  lines.push("  }");
-  lines.push("");
-  lines.push("  private async handleHttpError(response: Response, path: string): Promise<void> {");
-  lines.push("    if (response.ok) return;");
-  lines.push("");
-  lines.push("    const requestID = response.headers.get('x-request-id') ?? '';");
-  lines.push("    let data: any = {};");
-  lines.push("    try { data = await response.json(); } catch {}");
-  lines.push("    const { message, code, errors } = data;");
-  lines.push("");
-  lines.push("    switch (response.status) {");
-  lines.push("      case 400: throw new BadRequestException({ code, message, requestID });");
-  lines.push("      case 401: throw new UnauthorizedException(requestID);");
-  lines.push("      case 404: throw new NotFoundException({ code, message, path, requestID });");
-  lines.push("      case 409: throw new ConflictException({ message, requestID });");
-  lines.push("      case 422: throw new UnprocessableEntityException({ code, errors, message, requestID });");
-  lines.push("      case 429: {");
-  lines.push("        const retryAfter = Number(response.headers.get('retry-after')) || undefined;");
-  lines.push("        throw new RateLimitExceededException(message ?? 'Too many requests', requestID, retryAfter);");
-  lines.push("      }");
-  lines.push("      default: throw new GenericServerException(response.status, message ?? 'Server error', requestID);");
-  lines.push("    }");
-  lines.push("  }");
-  lines.push("}");
-  return { path: "src/workos.ts", content: lines.join("\n"), skipIfExists: true, integrateTarget: false };
-}
-var RESERVED_BARREL_NAMES = /* @__PURE__ */ new Set(["List", "ListResponse", "ListMetadata", "AutoPaginatable", "PaginationOptions"]);
-function generateBarrel(spec, ctx) {
-  const lines = [];
-  const modelToService = assignModelsToServices(spec.models, spec.services);
-  const serviceNameMap = buildServiceNameMap(spec.services, ctx);
-  const resolveDir = (irService) => irService ? serviceDirName(serviceNameMap.get(irService) ?? irService) : "common";
-  lines.push("export * from './common/exceptions';");
-  lines.push("export { AutoPaginatable } from './common/utils/pagination';");
-  lines.push("export type { List, ListMetadata, ListResponse } from './common/utils/pagination';");
-  lines.push("export type { PaginationOptions } from './common/interfaces/pagination-options.interface';");
-  lines.push("export type { WorkOSOptions } from './common/interfaces/workos-options.interface';");
-  lines.push("export type { PostOptions } from './common/interfaces/post-options.interface';");
-  lines.push("export type { GetOptions } from './common/interfaces/get-options.interface';");
-  lines.push("");
-  for (const service of spec.services) {
-    const resolvedName = resolveServiceName(service, ctx);
-    const serviceDir = serviceDirName(resolvedName);
-    const serviceModels = spec.models.filter((m) => modelToService.get(m.name) === service.name);
-    for (const model of serviceModels) {
-      const name = resolveInterfaceName(model.name, ctx);
-      const wireName = wireInterfaceName(name);
-      if (RESERVED_BARREL_NAMES.has(name) || RESERVED_BARREL_NAMES.has(wireName)) continue;
-      lines.push(
-        `export type { ${name}, ${wireName} } from './${serviceDir}/interfaces/${fileName(model.name)}.interface';`
-      );
-    }
-    lines.push(`export { ${resolvedName} } from './${serviceDir}/${fileName(resolvedName)}';`);
-    lines.push("");
-  }
-  const unassignedModels = spec.models.filter((m) => !modelToService.has(m.name));
-  for (const model of unassignedModels) {
-    const name = resolveInterfaceName(model.name, ctx);
-    const wireName = wireInterfaceName(name);
-    if (RESERVED_BARREL_NAMES.has(name) || RESERVED_BARREL_NAMES.has(wireName)) continue;
-    lines.push(`export type { ${name}, ${wireName} } from './common/interfaces/${fileName(model.name)}.interface';`);
-  }
-  for (const enumDef of spec.enums) {
-    const enumService = findEnumService(enumDef.name, spec.services);
-    const dir = resolveDir(enumService);
-    lines.push(`export type { ${enumDef.name} } from './${dir}/interfaces/${fileName(enumDef.name)}.interface';`);
-  }
-  lines.push("");
-  lines.push("export { WorkOS } from './workos';");
-  return { path: "src/index.ts", content: lines.join("\n"), skipIfExists: true };
-}
-function findEnumService(enumName, services) {
-  for (const service of services) {
-    for (const op of service.operations) {
-      const refs = [];
-      const collect = (ref) => {
-        if (ref?.kind === "enum" && ref.name === enumName) refs.push(ref.name);
-        if (ref?.items) collect(ref.items);
-        if (ref?.inner) collect(ref.inner);
-        if (ref?.variants) ref.variants.forEach(collect);
-        if (ref?.valueType) collect(ref.valueType);
-      };
-      if (op.requestBody) collect(op.requestBody);
-      collect(op.response);
-      for (const p of [...op.pathParams, ...op.queryParams]) {
-        collect(p.type);
-      }
-      if (refs.length > 0) return service.name;
-    }
-  }
-  return void 0;
-}
-function generatePackageJson(ctx) {
-  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() {
-  const config = {
-    compilerOptions: {
-      target: "ES2020",
-      module: "CommonJS",
-      lib: ["ES2020"],
-      declaration: true,
-      strict: 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
-  };
-}
-
-// src/node/errors.ts
-function generateErrors() {
-  return [
-    {
-      path: "src/common/exceptions/bad-request.exception.ts",
-      content: `export class BadRequestException extends Error {
-  readonly status = 400;
-  readonly name = 'BadRequestException';
-  readonly requestID: string;
-  readonly code?: string;
-
-  constructor({
-    code,
-    message,
-    requestID,
-  }: {
-    code?: string;
-    message?: string;
-    requestID: string;
-  }) {
-    super();
-    this.message = message ?? 'Bad request';
-    this.requestID = requestID;
-    if (code) this.code = code;
-  }
-}`,
-      skipIfExists: true,
-      integrateTarget: false
-    },
-    {
-      path: "src/common/exceptions/unauthorized.exception.ts",
-      content: `export class UnauthorizedException extends Error {
-  readonly status = 401;
-  readonly name = 'UnauthorizedException';
-  readonly requestID: string;
-
-  constructor(requestID: string) {
-    super();
-    this.message = 'Unauthorized';
-    this.requestID = requestID;
-  }
-}`,
-      skipIfExists: true,
-      integrateTarget: false
-    },
-    {
-      path: "src/common/exceptions/not-found.exception.ts",
-      content: `export class NotFoundException extends Error {
-  readonly status = 404;
-  readonly name = 'NotFoundException';
-  readonly requestID: string;
-  readonly code?: string;
-
-  constructor({
-    code,
-    message,
-    path,
-    requestID,
-  }: {
-    code?: string;
-    message?: string;
-    path: string;
-    requestID: string;
-  }) {
-    super();
-    this.message =
-      message ?? \`The requested path '\${path}' could not be found.\`;
-    this.requestID = requestID;
-    if (code) this.code = code;
-  }
-}`,
-      skipIfExists: true,
-      integrateTarget: false
-    },
-    {
-      path: "src/common/exceptions/conflict.exception.ts",
-      content: `export class ConflictException extends Error {
-  readonly status = 409;
-  readonly name = 'ConflictException';
-  readonly requestID: string;
-
-  constructor({
-    message,
-    requestID,
-  }: {
-    message?: string;
-    error?: string;
-    requestID: string;
-  }) {
-    super();
-    this.message = message ?? 'Conflict';
-    this.requestID = requestID;
-  }
-}`,
-      skipIfExists: true,
-      integrateTarget: false
-    },
-    {
-      path: "src/common/exceptions/unprocessable-entity.exception.ts",
-      content: `export interface UnprocessableEntityError {
-  code: string;
-}
-
-export class UnprocessableEntityException extends Error {
-  readonly status = 422;
-  readonly name = 'UnprocessableEntityException';
-  readonly requestID: string;
-  readonly code?: string;
-
-  constructor({
-    code,
-    errors,
-    message,
-    requestID,
-  }: {
-    code?: string;
-    errors?: UnprocessableEntityError[];
-    message?: string;
-    requestID: string;
-  }) {
-    super();
-    this.requestID = requestID;
-    this.message = message ?? 'Unprocessable entity';
-    if (code) this.code = code;
-    if (errors) {
-      const requirement =
-        errors.length === 1 ? 'requirement' : 'requirements';
-      this.message = \`The following \${requirement} must be met:\\n\`;
-      for (const { code: errCode } of errors) {
-        this.message = this.message.concat(\`\\t\${errCode}\\n\`);
-      }
-    }
-  }
-}`,
-      skipIfExists: true,
-      integrateTarget: false
-    },
-    {
-      path: "src/common/exceptions/rate-limit-exceeded.exception.ts",
-      content: `export class RateLimitExceededException extends Error {
-  readonly status = 429;
-  readonly name = 'RateLimitExceededException';
-  readonly requestID: string;
-  readonly retryAfter?: number;
-
-  constructor(message: string, requestID: string, retryAfter?: number) {
-    super();
-    this.message = message ?? 'Too many requests';
-    this.requestID = requestID;
-    this.retryAfter = retryAfter;
-  }
-}`,
-      skipIfExists: true,
-      integrateTarget: false
-    },
-    {
-      path: "src/common/exceptions/generic-server.exception.ts",
-      content: `export class GenericServerException extends Error {
-  readonly status: number;
-  readonly name = 'GenericServerException';
-  readonly requestID: string;
-
-  constructor(status: number, message: string, requestID: string) {
-    super();
-    this.status = status;
-    this.message = message ?? 'Server error';
-    this.requestID = requestID;
-  }
-}`,
-      skipIfExists: true,
-      integrateTarget: false
-    },
-    {
-      path: "src/common/exceptions/no-api-key-provided.exception.ts",
-      content: `export class NoApiKeyProvidedException extends Error {
-  readonly name = 'NoApiKeyProvidedException';
-
-  constructor() {
-    super();
-    this.message =
-      'No API key provided. Pass it to the WorkOS constructor or set the WORKOS_API_KEY environment variable.';
-  }
-}`,
-      skipIfExists: true,
-      integrateTarget: false
-    },
-    {
-      path: "src/common/exceptions/index.ts",
-      content: `export { BadRequestException } from './bad-request.exception';
-export { UnauthorizedException } from './unauthorized.exception';
-export { NotFoundException } from './not-found.exception';
-export { ConflictException } from './conflict.exception';
-export {
-  UnprocessableEntityException,
-  type UnprocessableEntityError,
-} from './unprocessable-entity.exception';
-export { RateLimitExceededException } from './rate-limit-exceeded.exception';
-export { GenericServerException } from './generic-server.exception';
-export { NoApiKeyProvidedException } from './no-api-key-provided.exception';`,
-      skipIfExists: true,
-      integrateTarget: false
-    }
-  ];
-}
-
-// src/node/config.ts
-function generateConfig() {
-  return [
-    {
-      path: "src/common/interfaces/workos-options.interface.ts",
-      content: `export interface WorkOSOptions {
-  apiKey?: string;
-  apiHostname?: string;
-  https?: boolean;
-  port?: number;
-  config?: RequestInit;
-  fetchFn?: typeof fetch;
-  clientId?: string;
-  timeout?: number;
-}
-
-export interface AppInfo {
-  name: string;
-  version?: string;
-}`,
-      skipIfExists: true,
-      integrateTarget: false
-    },
-    {
-      path: "src/common/interfaces/post-options.interface.ts",
-      content: `export interface PostOptions {
-  query?: Record<string, any>;
-  idempotencyKey?: string;
-  warrantToken?: string;
-  skipApiKeyCheck?: boolean;
-}`,
-      skipIfExists: true,
-      integrateTarget: false
-    },
-    {
-      path: "src/common/interfaces/get-options.interface.ts",
-      content: `export interface GetOptions {
-  query?: Record<string, any>;
-  accessToken?: string;
-  warrantToken?: string;
-  skipApiKeyCheck?: boolean;
-}`,
-      skipIfExists: true,
-      integrateTarget: false
-    },
-    {
-      path: "src/common/interfaces/pagination-options.interface.ts",
-      content: `export interface PaginationOptions {
-  limit?: number;
-  before?: string | null;
-  after?: string | null;
-  order?: 'asc' | 'desc';
-}`,
-      skipIfExists: true,
-      integrateTarget: false
-    },
-    {
-      path: "src/common/interfaces/request-exception.interface.ts",
-      content: `export interface RequestException {
-  readonly status: number;
-  readonly name: string;
-  readonly requestID: string;
-  readonly code?: string;
-}`,
-      skipIfExists: true,
-      integrateTarget: false
-    }
-  ];
-}
-
-// src/node/common.ts
-function generateCommon() {
-  return [
-    {
-      path: "src/common/utils/pagination.ts",
-      content: paginationContent(),
-      skipIfExists: true,
-      integrateTarget: false
-    },
-    {
-      path: "src/common/utils/fetch-and-deserialize.ts",
-      content: fetchAndDeserializeContent(),
-      skipIfExists: true,
-      integrateTarget: false
-    },
-    {
-      path: "src/common/serializers/list.serializer.ts",
-      content: listSerializerContent(),
-      skipIfExists: true,
-      integrateTarget: false
-    },
-    {
-      path: "src/common/utils/test-utils.ts",
-      content: testUtilsContent(),
-      skipIfExists: true,
-      integrateTarget: false
-    }
-  ];
-}
-function paginationContent() {
-  return `import type { PaginationOptions } from '../interfaces/pagination-options.interface';
-
-export interface ListMetadata {
-  before: string | null;
-  after: string | null;
-}
-
-export interface List<T> {
-  object: 'list';
-  data: T[];
-  listMetadata: ListMetadata;
-}
-
-export interface ListResponse<T> {
-  object: 'list';
-  data: T[];
-  list_metadata: {
-    before: string | null;
-    after: string | null;
-  };
-}
-
-export class AutoPaginatable<
-  ResourceType,
-  ParametersType extends PaginationOptions = PaginationOptions,
-> {
-  readonly object = 'list' as const;
-  readonly options: ParametersType;
-
-  constructor(
-    protected list: List<ResourceType>,
-    private apiCall: (params: PaginationOptions) => Promise<List<ResourceType>>,
-    options?: ParametersType,
-  ) {
-    this.options = options ?? ({} as ParametersType);
-  }
-
-  get data(): ResourceType[] {
-    return this.list.data;
-  }
-
-  get listMetadata() {
-    return this.list.listMetadata;
-  }
-
-  private async *generatePages(
-    params: PaginationOptions,
-  ): AsyncGenerator<ResourceType[]> {
-    const result = await this.apiCall({
-      ...this.options,
-      limit: 100,
-      after: params.after,
-    });
-    yield result.data;
-    if (result.listMetadata.after) {
-      await new Promise((resolve) => setTimeout(resolve, 350));
-      yield* this.generatePages({ after: result.listMetadata.after });
-    }
-  }
-
-  async autoPagination(): Promise<ResourceType[]> {
-    if (this.options.limit) {
-      return this.data;
-    }
-    const results: ResourceType[] = [];
-    for await (const page of this.generatePages({
-      after: this.options.after,
-    })) {
-      results.push(...page);
-    }
-    return results;
-  }
-}`;
-}
-function fetchAndDeserializeContent() {
-  return `import type { WorkOS } from '../../workos';
-import type { PaginationOptions } from '../interfaces/pagination-options.interface';
-import type { List, ListResponse } from './pagination';
-
-function setDefaultOptions(
-  options?: PaginationOptions,
-): Record<string, any> {
-  return {
-    order: 'desc',
-    ...options,
-  };
-}
-
-function deserializeList<T, U>(
-  data: ListResponse<T>,
-  deserializeFn: (item: T) => U,
-): List<U> {
-  return {
-    data: data.data.map(deserializeFn),
-    listMetadata: {
-      before: data.list_metadata.before,
-      after: data.list_metadata.after,
-    },
-  };
-}
-
-export const fetchAndDeserialize = async <T, U>(
-  workos: WorkOS,
-  endpoint: string,
-  deserializeFn: (data: T) => U,
-  options?: PaginationOptions,
-): Promise<List<U>> => {
-  const { data } = await workos.get<ListResponse<T>>(endpoint, {
-    query: setDefaultOptions(options),
-  });
-  return deserializeList(data, deserializeFn);
-};`;
-}
-function listSerializerContent() {
-  return `import type { ListMetadata, ListResponse } from '../utils/pagination';
-
-export function deserializeListMetadata(
-  metadata: ListResponse<any>['list_metadata'],
-): ListMetadata {
-  return {
-    before: metadata.before,
-    after: metadata.after,
-  };
-}`;
-}
-function testUtilsContent() {
-  return `import fetch from 'jest-fetch-mock';
-
-interface MockParams {
-  status?: number;
-  headers?: Record<string, string>;
-  [key: string]: any;
-}
-
-export function fetchOnce(
-  response: any = {},
-  { status = 200, headers, ...rest }: MockParams = {},
-) {
-  return fetch.once(JSON.stringify(response), {
-    status,
-    headers: {
-      'content-type': 'application/json;charset=UTF-8',
-      ...headers,
-    },
-    ...rest,
-  });
-}
-
-export function fetchURL(): string {
-  return String(fetch.mock.calls[0][0]);
-}
-
-export function fetchSearchParams(): Record<string, string> {
-  return Object.fromEntries(new URL(fetchURL()).searchParams);
-}
-
-export function fetchHeaders(): Record<string, string> {
-  const headers = fetch.mock.calls[0][1]?.headers ?? {};
-  return headers as Record<string, string>;
-}
-
-export function fetchBody({ raw = false } = {}): any {
-  const body = fetch.mock.calls[0][1]?.body;
-  if (body instanceof URLSearchParams) return body.toString();
-  if (raw) return body;
-  return JSON.parse(String(body));
-}`;
-}
-
-// src/node/tests.ts
-import { planOperation as planOperation2, toCamelCase as toCamelCase2 } from "@workos/oagen";
-
-// src/node/fixtures.ts
-function generateFixtures(spec, ctx) {
-  if (spec.models.length === 0) return [];
-  const modelToService = assignModelsToServices(spec.models, spec.services);
-  const serviceNameMap = ctx ? buildServiceNameMap(ctx.spec.services, ctx) : /* @__PURE__ */ new Map();
-  const resolveDir = (irService) => irService ? serviceDirName(serviceNameMap.get(irService) ?? irService) : "common";
-  const modelMap = new Map(spec.models.map((m) => [m.name, m]));
-  const enumMap = new Map(spec.enums.map((e) => [e.name, e]));
-  const files = [];
-  for (const model of spec.models) {
-    const service = modelToService.get(model.name);
-    const dirName = resolveDir(service);
-    const fixture = generateModelFixture(model, modelMap, enumMap);
-    files.push({
-      path: `src/${dirName}/fixtures/${fileName(model.name)}.fixture.json`,
-      content: JSON.stringify(fixture, null, 2)
-    });
-  }
-  for (const service of spec.services) {
-    const resolvedName = ctx ? resolveServiceName(service, ctx) : service.name;
-    const serviceDir = serviceDirName(resolvedName);
-    for (const op of service.operations) {
-      if (op.pagination) {
-        const itemModel = op.pagination.itemType.kind === "model" ? modelMap.get(op.pagination.itemType.name) : null;
-        if (itemModel) {
-          const fixture = generateModelFixture(itemModel, modelMap, enumMap);
-          const listFixture = {
-            data: [fixture],
-            list_metadata: {
-              before: null,
-              after: null
-            }
-          };
-          files.push({
-            path: `src/${serviceDir}/fixtures/list-${fileName(itemModel.name)}.fixture.json`,
-            content: JSON.stringify(listFixture, null, 2)
-          });
-        }
-      }
-    }
-  }
-  return files;
-}
-function generateModelFixture(model, modelMap, enumMap) {
-  const fixture = {};
-  for (const field of model.fields) {
-    const wireName = wireFieldName(field.name);
-    fixture[wireName] = generateFieldValue(field.type, field.name, modelMap, enumMap);
-  }
-  return fixture;
-}
-function generateFieldValue(ref, fieldName2, modelMap, enumMap) {
-  switch (ref.kind) {
-    case "primitive":
-      return generatePrimitiveValue(ref.type, ref.format, fieldName2);
-    case "literal":
-      return ref.value;
-    case "enum": {
-      const e = enumMap.get(ref.name);
-      return e?.values[0]?.value ?? "unknown";
-    }
-    case "model": {
-      const nested = modelMap.get(ref.name);
-      if (nested) return generateModelFixture(nested, modelMap, enumMap);
-      return {};
-    }
-    case "array": {
-      const item = generateFieldValue(ref.items, fieldName2, modelMap, enumMap);
-      return [item];
-    }
-    case "nullable":
-      return generateFieldValue(ref.inner, fieldName2, modelMap, enumMap);
-    case "union":
-      if (ref.variants.length > 0) {
-        return generateFieldValue(ref.variants[0], fieldName2, modelMap, enumMap);
-      }
-      return null;
-    case "map":
-      return { key: generateFieldValue(ref.valueType, "value", modelMap, enumMap) };
-  }
-}
-function generatePrimitiveValue(type, format, name) {
-  switch (type) {
-    case "string":
-      if (format === "date-time") return "2023-01-01T00:00:00.000Z";
-      if (format === "date") return "2023-01-01";
-      if (format === "uuid") return "00000000-0000-0000-0000-000000000000";
-      if (name.includes("id")) return `${name}_01234`;
-      if (name.includes("email")) return "test@example.com";
-      if (name.includes("url") || name.includes("uri")) return "https://example.com";
-      if (name.includes("name")) return "Test";
-      return `test_${name}`;
-    case "integer":
-      return 1;
-    case "number":
-      return 1;
-    case "boolean":
-      return true;
-    case "unknown":
-      return {};
-    default:
-      return null;
-  }
-}
-
-// src/node/tests.ts
-function generateTests(spec, ctx) {
-  const files = [];
-  const fixtures = generateFixtures(spec, ctx);
-  for (const f of fixtures) {
-    files.push({ path: f.path, content: f.content, headerPlacement: "skip" });
-  }
-  const modelMap = new Map(spec.models.map((m) => [m.name, m]));
-  for (const service of spec.services) {
-    files.push(generateServiceTest(service, spec, ctx, modelMap));
-  }
-  return files;
-}
-function generateServiceTest(service, spec, ctx, modelMap) {
-  const resolvedName = resolveServiceName(service, ctx);
-  const serviceDir = serviceDirName(resolvedName);
-  const serviceClass = resolvedName;
-  const serviceProp = servicePropertyName(resolvedName);
-  const testPath = `src/${serviceDir}/${fileName(resolvedName)}.spec.ts`;
-  const lines = [];
-  lines.push("import fetch from 'jest-fetch-mock';");
-  lines.push("import {");
-  lines.push("  fetchOnce,");
-  lines.push("  fetchURL,");
-  lines.push("  fetchSearchParams,");
-  lines.push("  fetchBody,");
-  lines.push("} from '../common/utils/test-utils';");
-  lines.push("import { WorkOS } from '../workos';");
-  lines.push("");
-  const fixtureImports = /* @__PURE__ */ new Set();
-  for (const op of service.operations) {
-    const plan = planOperation2(op);
-    if (plan.isPaginated && op.pagination) {
-      const itemModelName = op.pagination.itemType.kind === "model" ? op.pagination.itemType.name : null;
-      if (itemModelName) {
-        fixtureImports.add(
-          `import list${itemModelName}Fixture from './fixtures/list-${fileName(itemModelName)}.fixture.json';`
-        );
-      }
-    } else if (plan.responseModelName) {
-      fixtureImports.add(
-        `import ${toCamelCase2(plan.responseModelName)}Fixture from './fixtures/${fileName(plan.responseModelName)}.fixture.json';`
-      );
-    }
-  }
-  for (const imp of fixtureImports) {
-    lines.push(imp);
-  }
-  lines.push("");
-  lines.push("const workos = new WorkOS('sk_test_Sz3IQjepeSWaI4cMS4ms4sMuU');");
-  lines.push("");
-  lines.push(`describe('${serviceClass}', () => {`);
-  lines.push("  beforeEach(() => fetch.resetMocks());");
-  for (const op of service.operations) {
-    const plan = planOperation2(op);
-    const method = resolveMethodName(op, service, ctx);
-    lines.push("");
-    lines.push(`  describe('${method}', () => {`);
-    if (plan.isPaginated) {
-      renderPaginatedTest(lines, op, plan, method, serviceProp, modelMap);
-    } else if (plan.isDelete) {
-      renderDeleteTest(lines, op, method, serviceProp);
-    } else if (plan.hasBody && plan.responseModelName) {
-      renderBodyTest(lines, op, plan, method, serviceProp, modelMap);
-    } else if (plan.responseModelName) {
-      renderGetTest(lines, op, plan, method, serviceProp, modelMap);
-    } else {
-      renderVoidTest(lines, op, method, serviceProp);
-    }
-    if (plan.responseModelName || plan.isPaginated) {
-      renderErrorTest(lines, op, plan, method, serviceProp);
-    }
-    lines.push("  });");
-  }
-  lines.push("});");
-  return { path: testPath, content: lines.join("\n"), skipIfExists: true, integrateTarget: false };
-}
-function renderPaginatedTest(lines, op, plan, method, serviceProp, modelMap) {
-  const itemModelName = op.pagination?.itemType.kind === "model" ? op.pagination.itemType.name : "Item";
-  lines.push("    it('returns paginated results', async () => {");
-  lines.push(`      fetchOnce(list${itemModelName}Fixture);`);
-  lines.push("");
-  lines.push(`      const { data, listMetadata } = await workos.${serviceProp}.${method}();`);
-  lines.push("");
-  lines.push(`      expect(fetchURL()).toContain('${op.path.split("{")[0]}');`);
-  lines.push("      expect(fetchSearchParams()).toHaveProperty('order');");
-  lines.push("      expect(Array.isArray(data)).toBe(true);");
-  lines.push("      expect(listMetadata).toBeDefined();");
-  const itemModel = modelMap.get(itemModelName);
-  if (itemModel) {
-    const assertions = buildFieldAssertions(itemModel, "data[0]");
-    if (assertions.length > 0) {
-      lines.push("      expect(data.length).toBeGreaterThan(0);");
-      for (const assertion of assertions) {
-        lines.push(`      ${assertion}`);
-      }
-    }
-  }
-  lines.push("    });");
-}
-function renderDeleteTest(lines, op, method, serviceProp) {
-  const hasPathParam = op.pathParams.length > 0;
-  const args = hasPathParam ? "'test_id'" : "";
-  lines.push("    it('sends a DELETE request', async () => {");
-  lines.push("      fetchOnce({}, { status: 204 });");
-  lines.push("");
-  lines.push(`      await workos.${serviceProp}.${method}(${args});`);
-  lines.push("");
-  lines.push(`      expect(fetchURL()).toContain('${op.path.split("{")[0]}');`);
-  if (hasPathParam) {
-    lines.push("      expect(fetchURL()).toContain('test_id');");
-  }
-  lines.push("    });");
-}
-function renderBodyTest(lines, op, plan, method, serviceProp, modelMap) {
-  const responseModelName = plan.responseModelName;
-  const fixture = `${toCamelCase2(responseModelName)}Fixture`;
-  const hasPathParam = op.pathParams.length > 0;
-  const pathArg = hasPathParam ? "'test_id', " : "";
-  lines.push("    it('sends the correct request and returns result', async () => {");
-  lines.push(`      fetchOnce(${fixture});`);
-  lines.push("");
-  lines.push(`      const result = await workos.${serviceProp}.${method}(${pathArg}{});`);
-  lines.push("");
-  lines.push(`      expect(fetchURL()).toContain('${op.path.split("{")[0]}');`);
-  if (hasPathParam) {
-    lines.push("      expect(fetchURL()).toContain('test_id');");
-  }
-  lines.push("      expect(fetchBody()).toBeDefined();");
-  lines.push("      expect(result).toBeDefined();");
-  const responseModel = modelMap.get(responseModelName);
-  if (responseModel) {
-    const assertions = buildFieldAssertions(responseModel, "result");
-    for (const assertion of assertions) {
-      lines.push(`      ${assertion}`);
-    }
-  }
-  lines.push("    });");
-}
-function renderGetTest(lines, op, plan, method, serviceProp, modelMap) {
-  const responseModelName = plan.responseModelName;
-  const fixture = `${toCamelCase2(responseModelName)}Fixture`;
-  const hasPathParam = op.pathParams.length > 0;
-  const args = hasPathParam ? "'test_id'" : "";
-  lines.push("    it('returns the expected result', async () => {");
-  lines.push(`      fetchOnce(${fixture});`);
-  lines.push("");
-  lines.push(`      const result = await workos.${serviceProp}.${method}(${args});`);
-  lines.push("");
-  lines.push(`      expect(fetchURL()).toContain('${op.path.split("{")[0]}');`);
-  if (hasPathParam) {
-    lines.push("      expect(fetchURL()).toContain('test_id');");
-  }
-  lines.push("      expect(result).toBeDefined();");
-  const responseModel = modelMap.get(responseModelName);
-  if (responseModel) {
-    const assertions = buildFieldAssertions(responseModel, "result");
-    for (const assertion of assertions) {
-      lines.push(`      ${assertion}`);
-    }
-  }
-  lines.push("    });");
-}
-function renderVoidTest(lines, op, method, serviceProp) {
-  const hasPathParam = op.pathParams.length > 0;
-  const args = hasPathParam ? "'test_id'" : "";
-  lines.push("    it('sends the request', async () => {");
-  lines.push("      fetchOnce({});");
-  lines.push("");
-  lines.push(`      await workos.${serviceProp}.${method}(${args});`);
-  lines.push("");
-  lines.push(`      expect(fetchURL()).toContain('${op.path.split("{")[0]}');`);
-  if (hasPathParam) {
-    lines.push("      expect(fetchURL()).toContain('test_id');");
-  }
-  lines.push("    });");
-}
-function renderErrorTest(lines, op, plan, method, serviceProp) {
-  const hasPathParam = op.pathParams.length > 0;
-  const isPaginated = plan.isPaginated;
-  const hasBody = plan.hasBody;
-  let args;
-  if (isPaginated) {
-    args = "";
-  } else if (hasBody && hasPathParam) {
-    args = "'test_id', {}";
-  } else if (hasBody) {
-    args = "{}";
-  } else if (hasPathParam) {
-    args = "'test_id'";
-  } else {
-    args = "";
-  }
-  lines.push("");
-  lines.push("    it('throws on unauthorized', async () => {");
-  lines.push("      fetchOnce({ message: 'Unauthorized' }, { status: 401 });");
-  lines.push("");
-  lines.push(`      await expect(workos.${serviceProp}.${method}(${args})).rejects.toThrow();`);
-  lines.push("    });");
-}
-function buildFieldAssertions(model, accessor) {
-  const assertions = [];
-  for (const field of model.fields) {
-    if (!field.required) continue;
-    const value = fixtureValueForType(field.type, field.name);
-    if (value === null) continue;
-    const domainField = fieldName(field.name);
-    assertions.push(`expect(${accessor}.${domainField}).toBe(${value});`);
-  }
-  return assertions;
-}
-function fixtureValueForType(ref, name) {
-  switch (ref.kind) {
-    case "primitive":
-      return fixtureValueForPrimitive(ref.type, ref.format, name);
-    case "literal":
-      return typeof ref.value === "string" ? `'${ref.value}'` : String(ref.value);
-    default:
-      return null;
-  }
-}
-function fixtureValueForPrimitive(type, format, name) {
-  switch (type) {
-    case "string":
-      if (format === "date-time") return "'2023-01-01T00:00:00.000Z'";
-      if (format === "date") return "'2023-01-01'";
-      if (format === "uuid") return "'00000000-0000-0000-0000-000000000000'";
-      if (name.includes("id")) return `'${wireFieldName(name)}_01234'`;
-      if (name.includes("email")) return "'test@example.com'";
-      if (name.includes("url") || name.includes("uri")) return "'https://example.com'";
-      if (name.includes("name")) return "'Test'";
-      return `'test_${wireFieldName(name)}'`;
-    case "integer":
-      return "1";
-    case "number":
-      return "1";
-    case "boolean":
-      return "true";
-    default:
-      return null;
-  }
-}
-
-// src/node/manifest.ts
-function generateManifest(spec, ctx) {
-  const manifest = {};
-  for (const service of spec.services) {
-    const propName = servicePropertyName(resolveServiceName(service, ctx));
-    for (const op of service.operations) {
-      const httpKey = `${op.httpMethod.toUpperCase()} ${op.path}`;
-      const method = resolveMethodName(op, service, ctx);
-      manifest[httpKey] = { sdkMethod: method, service: propName };
-    }
-  }
-  return [
-    {
-      path: "smoke-manifest.json",
-      content: JSON.stringify(manifest, null, 2),
-      integrateTarget: false
-    }
-  ];
-}
-
-// src/node/index.ts
-var nodeEmitter = {
-  language: "node",
-  generateModels(models, ctx) {
-    return [...generateModels(models, ctx), ...generateSerializers(models, ctx)];
-  },
-  generateEnums(enums, ctx) {
-    return generateEnums(enums, ctx);
-  },
-  generateResources(services, ctx) {
-    return generateResources(services, ctx);
-  },
-  generateClient(spec, ctx) {
-    return generateClient(spec, ctx);
-  },
-  generateErrors(_ctx) {
-    return generateErrors();
-  },
-  generateConfig(_ctx) {
-    return [...generateConfig(), ...generateCommon()];
-  },
-  generateTypeSignatures(_spec, _ctx) {
-    return [];
-  },
-  generateTests(spec, ctx) {
-    return generateTests(spec, ctx);
-  },
-  generateManifest(spec, ctx) {
-    return generateManifest(spec, ctx);
-  },
-  fileHeader() {
-    return "// This file is auto-generated by oagen. Do not edit.";
-  }
-};
-export {
-  nodeEmitter
-};