@xlr-lib/xlr-converters 0.1.1-next.4 → 0.1.1-next.6

package/dist/cjs/index.cjs

@@ -34,12 +34,269 @@ __export(src_exports, {
   TSWriter: () => TSWriter,
   TsConverter: () => TsConverter,
   converter: () => converter,
+  exportTypesToTypeScript: () => exportTypesToTypeScript,
   writeManifest: () => writeManifest
 });
 module.exports = __toCommonJS(src_exports);
 
 // ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/ts/ts-to-xlr.ts
+var import_typescript3 = __toESM(require("typescript"));
+
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/ts/ts-utils.ts
 var import_typescript = __toESM(require("typescript"));
+function isOptionalProperty(node) {
+  return node.questionToken?.kind === import_typescript.default.SyntaxKind.QuestionToken;
+}
+function isGenericInterfaceDeclaration(node) {
+  const length = node.typeParameters?.length;
+  return length ? length > 0 : false;
+}
+function isGenericTypeDeclaration(node) {
+  const length = node.typeParameters?.length;
+  return length ? length > 0 : false;
+}
+function isTypeReferenceGeneric(node, typeChecker) {
+  const symbol = typeChecker.getSymbolAtLocation(node.typeName);
+  if (symbol && symbol.declarations) {
+    return symbol.declarations[0].kind === import_typescript.default.SyntaxKind.TypeParameter;
+  }
+  return false;
+}
+function isTopLevelDeclaration(node) {
+  return node.kind === import_typescript.default.SyntaxKind.InterfaceDeclaration || node.kind === import_typescript.default.SyntaxKind.TypeAliasDeclaration;
+}
+function isTopLevelNode(node) {
+  return node.kind === import_typescript.default.SyntaxKind.InterfaceDeclaration || node.kind === import_typescript.default.SyntaxKind.TypeAliasDeclaration || node.kind === import_typescript.default.SyntaxKind.VariableStatement;
+}
+function tsStripOptionalType(node) {
+  return import_typescript.default.isOptionalTypeNode(node) ? node.type : node;
+}
+function isExportedDeclaration(node) {
+  const modifiers = import_typescript.default.canHaveModifiers(node) ? import_typescript.default.getModifiers(node) : void 0;
+  if (modifiers) {
+    return modifiers.some((m) => m.kind === import_typescript.default.SyntaxKind.ExportKeyword);
+  }
+  return false;
+}
+function isNodeExported(node) {
+  return (import_typescript.default.getCombinedModifierFlags(node) & import_typescript.default.ModifierFlags.Export) !== 0 || !!node.parent && node.parent.kind === import_typescript.default.SyntaxKind.SourceFile;
+}
+function getReferencedType(node, typeChecker) {
+  let symbol = typeChecker.getSymbolAtLocation(node.typeName);
+  if (symbol && (symbol.flags & import_typescript.default.SymbolFlags.Alias) === import_typescript.default.SymbolFlags.Alias) {
+    symbol = typeChecker.getAliasedSymbol(symbol);
+  }
+  const varDecl = symbol?.declarations?.[0];
+  if (varDecl && (import_typescript.default.isInterfaceDeclaration(varDecl) || import_typescript.default.isTypeAliasDeclaration(varDecl))) {
+    return { declaration: varDecl, exported: isNodeExported(varDecl) };
+  }
+}
+function isTypeScriptLibType(node, typeChecker) {
+  let symbol = typeChecker.getSymbolAtLocation(node.typeName);
+  if (!symbol) return false;
+  if ((symbol.flags & import_typescript.default.SymbolFlags.Alias) === import_typescript.default.SymbolFlags.Alias) {
+    symbol = typeChecker.getAliasedSymbol(symbol);
+  }
+  const declarations = symbol.getDeclarations();
+  if (!declarations || declarations.length === 0) return false;
+  return declarations.some((decl) => {
+    const sourceFile = decl.getSourceFile();
+    if (!sourceFile) return false;
+    const filePath = sourceFile.fileName;
+    return filePath.includes("/typescript/lib/") || filePath.includes("\\typescript\\lib\\") || filePath.endsWith(".d.ts") && filePath.includes("lib.");
+  });
+}
+function getStringLiteralsFromUnion(node) {
+  if (import_typescript.default.isUnionTypeNode(node)) {
+    return new Set(
+      node.types.map((type) => {
+        if (import_typescript.default.isLiteralTypeNode(type) && import_typescript.default.isStringLiteral(type.literal)) {
+          return type.literal.text;
+        }
+        return "";
+      })
+    );
+  }
+  if (import_typescript.default.isLiteralTypeNode(node) && import_typescript.default.isStringLiteral(node.literal)) {
+    return /* @__PURE__ */ new Set([node.literal.text]);
+  }
+  return /* @__PURE__ */ new Set();
+}
+function buildTemplateRegex(node, typeChecker) {
+  let regex = node.head.text;
+  node.templateSpans.forEach((span) => {
+    let type = span.type.kind;
+    if (import_typescript.default.isTypeReferenceNode(span.type)) {
+      let symbol = typeChecker.getSymbolAtLocation(
+        span.type.typeName
+      );
+      if (symbol && (symbol.flags & import_typescript.default.SymbolFlags.Alias) === import_typescript.default.SymbolFlags.Alias) {
+        symbol = typeChecker.getAliasedSymbol(symbol);
+      }
+      type = (symbol?.declarations?.[0]).type.kind;
+    }
+    if (type === import_typescript.default.SyntaxKind.StringKeyword) {
+      regex += ".*";
+    } else if (type === import_typescript.default.SyntaxKind.NumberKeyword) {
+      regex += "[0-9]*";
+    } else if (type === import_typescript.default.SyntaxKind.BooleanKeyword) {
+      regex += "true|false";
+    }
+    regex += span.literal.text;
+  });
+  return regex;
+}
+function isExportedModuleDeclaration(node) {
+  return isExportedDeclaration(node) && import_typescript.default.isModuleDeclaration(node);
+}
+
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/ts/annotations.ts
+var import_typescript2 = __toESM(require("typescript"));
+function extractDescription(text) {
+  if (!text) {
+    return {};
+  }
+  return { description: text };
+}
+function parentIsNonObjectPath(node) {
+  return node.parent && (import_typescript2.default.isArrayTypeNode(node.parent) || import_typescript2.default.isTupleTypeNode(node.parent) || import_typescript2.default.isOptionalTypeNode(node.parent) || import_typescript2.default.isRestTypeNode(node.parent) || import_typescript2.default.isUnionTypeNode(node.parent));
+}
+function recurseTypeChain(node, child) {
+  if (!node) {
+    return [];
+  }
+  if (import_typescript2.default.isArrayTypeNode(node) && node.parent && import_typescript2.default.isRestTypeNode(node.parent)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  if (import_typescript2.default.isRestTypeNode(node)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  if (import_typescript2.default.isOptionalTypeNode(node)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  if (import_typescript2.default.isUnionTypeNode(node)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  if (import_typescript2.default.isParenthesizedTypeNode(node)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  if (import_typescript2.default.isTypeLiteralNode(node)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  if (import_typescript2.default.isArrayTypeNode(node)) {
+    return ["[]", ...recurseTypeChain(node.parent, node)];
+  }
+  if (import_typescript2.default.isTupleTypeNode(node)) {
+    const pos = node.elements.indexOf(child);
+    return [
+      ...pos === -1 ? [] : [`${pos}`],
+      ...recurseTypeChain(node.parent, node)
+    ];
+  }
+  if (import_typescript2.default.isTypeAliasDeclaration(node) || import_typescript2.default.isInterfaceDeclaration(node) || import_typescript2.default.isPropertySignature(node)) {
+    return [node.name.getText(), ...recurseTypeChain(node.parent, node)];
+  }
+  if (parentIsNonObjectPath(node)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  return [];
+}
+function extractTitle(node) {
+  const typeNames = recurseTypeChain(node, void 0).reverse().join(".");
+  if (!typeNames.length) {
+    return {};
+  }
+  return { title: typeNames };
+}
+function stringifyDoc(docString) {
+  if (typeof docString === "undefined" || typeof docString === "string") {
+    return docString;
+  }
+  return docString.map(({ text }) => text).join(" ");
+}
+function extractTags(tags) {
+  const descriptions = [];
+  const examples = [];
+  const _default = [];
+  const see = [];
+  const meta = {};
+  const extractSee = (tag) => {
+    return `${tag.tagName ? `${tag.tagName?.getText()} ` : ""}${stringifyDoc(tag.comment)?.trim() ?? ""}`;
+  };
+  tags.forEach((tag) => {
+    if (!tag.comment) {
+      return;
+    }
+    if (tag.tagName.text === "example") {
+      examples.push(stringifyDoc(tag.comment)?.trim() ?? "");
+    } else if (tag.tagName.text === "default") {
+      _default.push(stringifyDoc(tag.comment)?.trim() ?? "");
+    } else if (tag.tagName.text === "see") {
+      see.push(extractSee(tag));
+    } else if (tag.tagName.text === "meta") {
+      const [key, value] = tag.comment.toString().split(/:(.*)/);
+      meta[key] = value?.trim() ?? "";
+    } else {
+      const text = stringifyDoc(tag.comment)?.trim() ?? "";
+      descriptions.push(`@${tag.tagName.text} ${text}`);
+    }
+  });
+  return {
+    ...descriptions.length === 0 ? {} : { description: descriptions.join("\n") },
+    ...examples.length === 0 ? {} : { examples },
+    ..._default.length === 0 ? {} : { default: _default.join("\n") },
+    ...see.length === 0 ? {} : { see },
+    ...meta && Object.keys(meta).length === 0 ? {} : { meta }
+  };
+}
+function join(t, separator = "\n") {
+  const unique = new Set(t).values();
+  return Array.from(unique).filter((s) => s !== void 0).join(separator).trim();
+}
+function mergeAnnotations(nodes) {
+  const name = nodes.find((n) => n.name)?.name;
+  const title = join(
+    nodes.map((n) => n.title),
+    ", "
+  );
+  const description = join(nodes.map((n) => n.description));
+  const _default = join(nodes.map((n) => n.default));
+  const comment = join(nodes.map((n) => n.comment));
+  const examples = join(
+    nodes.map(
+      (n) => Array.isArray(n.examples) ? join(n.examples) : n.examples
+    )
+  );
+  const see = join(
+    nodes.map((n) => Array.isArray(n.see) ? join(n.see) : n.see)
+  );
+  const meta = nodes.find((n) => n.meta)?.meta;
+  return {
+    ...name ? { name } : {},
+    ...title ? { title } : {},
+    ...description ? { description } : {},
+    ...examples ? { examples } : {},
+    ..._default ? { default: _default } : {},
+    ...see ? { see } : {},
+    ...comment ? { comment } : {},
+    ...meta ? { meta } : {}
+  };
+}
+function decorateNode(node) {
+  const { jsDoc } = node;
+  const titleAnnotation = extractTitle(node);
+  if (jsDoc && jsDoc.length) {
+    const first = jsDoc[0];
+    return mergeAnnotations([
+      extractDescription(stringifyDoc(first.comment)),
+      titleAnnotation,
+      extractTags(first.tags ?? [])
+    ]);
+  }
+  return titleAnnotation;
+}
+
+// ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/ts/ts-to-xlr.ts
 var import_xlr_utils = require("@xlr-lib/xlr-utils");
 
 // ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/types.ts
@@ -58,7 +315,7 @@ function isMappedTypeNode(x) {
   return ["Pick", "Omit", "Required", "Partial", "Exclude"].includes(x);
 }
 function getPropertyNameText(name) {
-  if (import_typescript.default.isIdentifier(name) || import_typescript.default.isStringLiteral(name) || import_typescript.default.isNumericLiteral(name)) {
+  if (import_typescript3.default.isIdentifier(name) || import_typescript3.default.isStringLiteral(name) || import_typescript3.default.isNumericLiteral(name)) {
     return name.text;
   }
   return name.getText();
@@ -83,11 +340,11 @@ var TsConverter = class {
   }
   /** Converts all exported objects to a XLR representation */
   convertSourceFile(sourceFile) {
-    const declarations = sourceFile.statements.filter(import_xlr_utils.isTopLevelNode);
-    const namespacedTypes = sourceFile.statements.filter((s) => (0, import_xlr_utils.isExportedModuleDeclaration)(s)).flatMap((module2) => {
-      if (module2.body && import_typescript.default.isModuleBlock(module2.body)) {
+    const declarations = sourceFile.statements.filter(isTopLevelNode);
+    const namespacedTypes = sourceFile.statements.filter((s) => isExportedModuleDeclaration(s)).flatMap((module2) => {
+      if (module2.body && import_typescript3.default.isModuleBlock(module2.body)) {
         const nameSpaceName = module2.name.text;
-        return module2.body.statements.filter(import_xlr_utils.isExportedDeclaration).filter(import_xlr_utils.isTopLevelNode).map((statement) => {
+        return module2.body.statements.filter(isExportedDeclaration).filter(isTopLevelNode).map((statement) => {
           const convertedNode = this.convertTopLevelNode(statement);
           return {
             ...convertedNode,
@@ -97,7 +354,7 @@ var TsConverter = class {
       }
       return [];
     });
-    const types = declarations.filter((declaration) => (0, import_xlr_utils.isExportedDeclaration)(declaration)).map((statement) => this.convertTopLevelNode(statement)).filter((v) => !!v);
+    const types = declarations.filter((declaration) => isExportedDeclaration(declaration)).map((statement) => this.convertTopLevelNode(statement)).filter((v) => !!v);
     types.push(...namespacedTypes);
     return {
       data: { version: 1, types },
@@ -107,7 +364,7 @@ var TsConverter = class {
   convertTopLevelNode(node) {
     const sourceFile = node.parent;
     const { fileName } = sourceFile;
-    if (import_typescript.default.isVariableStatement(node)) {
+    if (import_typescript3.default.isVariableStatement(node)) {
       return {
         source: fileName,
         ...this.convertVariable(node)
@@ -120,28 +377,28 @@ var TsConverter = class {
   }
   /** Converts a single type/interface declaration to XLRs */
   convertDeclaration(node) {
-    if (import_typescript.default.isTypeAliasDeclaration(node)) {
+    if (import_typescript3.default.isTypeAliasDeclaration(node)) {
       let genericTokens;
-      if ((0, import_xlr_utils.isGenericTypeDeclaration)(node)) {
+      if (isGenericTypeDeclaration(node)) {
         genericTokens = this.generateGenerics(node.typeParameters);
       }
       return {
         name: node.name.getText(),
         ...this.convertTsTypeNode(node.type) ?? AnyTypeNode,
-        ...(0, import_xlr_utils.decorateNode)(node),
+        ...decorateNode(node),
         genericTokens
       };
     }
-    if (import_typescript.default.isInterfaceDeclaration(node)) {
+    if (import_typescript3.default.isInterfaceDeclaration(node)) {
       let genericTokens;
-      if ((0, import_xlr_utils.isGenericInterfaceDeclaration)(node)) {
+      if (isGenericInterfaceDeclaration(node)) {
         genericTokens = this.generateGenerics(node.typeParameters);
       }
       const baseObject = {
         name: node.name.getText(),
         type: "object",
         ...this.tsObjectMembersToProperties(node),
-        ...(0, import_xlr_utils.decorateNode)(node),
+        ...decorateNode(node),
         genericTokens
       };
       if (node.heritageClauses) {
@@ -163,9 +420,9 @@ var TsConverter = class {
       const variable = variableDeclarations[0];
       if (variable.initializer) {
         let resultingNode;
-        if (variable.type && import_typescript.default.isTypeReferenceNode(variable.type) && import_typescript.default.isIdentifier(variable.type.typeName) && this.context.customPrimitives.includes(variable.type.typeName.text)) {
+        if (variable.type && import_typescript3.default.isTypeReferenceNode(variable.type) && import_typescript3.default.isIdentifier(variable.type.typeName) && this.context.customPrimitives.includes(variable.type.typeName.text)) {
           resultingNode = this.makeBasicRefNode(variable.type);
-        } else if (import_typescript.default.isCallExpression(variable.initializer) || import_typescript.default.isArrowFunction(variable.initializer)) {
+        } else if (import_typescript3.default.isCallExpression(variable.initializer) || import_typescript3.default.isArrowFunction(variable.initializer)) {
           resultingNode = this.resolveFunctionCall(
             variable.initializer,
             node.parent
@@ -200,80 +457,80 @@ var TsConverter = class {
   }
   /** Should not be called directly unless you want to bypass the cache, use `convertTsTypeNode` */
   tsNodeToType(node) {
-    if (import_typescript.default.isUnionTypeNode(node)) {
+    if (import_typescript3.default.isUnionTypeNode(node)) {
       return {
         type: "or",
         or: node.types.map((child) => this.convertTsTypeNode(child)).filter(import_xlr_utils.isNonNullable),
-        ...(0, import_xlr_utils.decorateNode)(node)
+        ...decorateNode(node)
       };
     }
-    if (import_typescript.default.isIntersectionTypeNode(node)) {
+    if (import_typescript3.default.isIntersectionTypeNode(node)) {
       return {
         type: "and",
         and: node.types.map((child) => this.convertTsTypeNode(child)).filter(import_xlr_utils.isNonNullable),
-        ...(0, import_xlr_utils.decorateNode)(node)
+        ...decorateNode(node)
       };
     }
-    if (import_typescript.default.isParenthesizedTypeNode(node)) {
+    if (import_typescript3.default.isParenthesizedTypeNode(node)) {
       const children = [];
       node.forEachChild((child) => {
         children.push(child);
       });
-      if (children[0]?.kind === import_typescript.default.SyntaxKind.OpenParenToken) {
+      if (children[0]?.kind === import_typescript3.default.SyntaxKind.OpenParenToken) {
         children.shift();
       }
-      if (children[children.length - 1]?.kind === import_typescript.default.SyntaxKind.CloseParenToken) {
+      if (children[children.length - 1]?.kind === import_typescript3.default.SyntaxKind.CloseParenToken) {
         children.pop();
       }
       const element = children[0];
-      if (children.length !== 1 || !import_typescript.default.isTypeNode(element)) {
+      if (children.length !== 1 || !import_typescript3.default.isTypeNode(element)) {
         this.context.throwError(
-          `Parenthesis type not understood. Length ${children.length}, Is Type Node: ${import_typescript.default.SyntaxKind[element.kind]}`
+          `Parenthesis type not understood. Length ${children.length}, Is Type Node: ${import_typescript3.default.SyntaxKind[element.kind]}`
         );
       }
       return this.convertTsTypeNode(element);
     }
-    if (node.kind === import_typescript.default.SyntaxKind.AnyKeyword) {
-      return { type: "any", ...(0, import_xlr_utils.decorateNode)(node) };
+    if (node.kind === import_typescript3.default.SyntaxKind.AnyKeyword) {
+      return { type: "any", ...decorateNode(node) };
     }
-    if (node.kind === import_typescript.default.SyntaxKind.UnknownKeyword) {
-      return { type: "unknown", ...(0, import_xlr_utils.decorateNode)(node) };
+    if (node.kind === import_typescript3.default.SyntaxKind.UnknownKeyword) {
+      return { type: "unknown", ...decorateNode(node) };
     }
-    if (node.kind === import_typescript.default.SyntaxKind.StringKeyword) {
-      return { type: "string", ...(0, import_xlr_utils.decorateNode)(node) };
+    if (node.kind === import_typescript3.default.SyntaxKind.StringKeyword) {
+      return { type: "string", ...decorateNode(node) };
     }
-    if (node.kind === import_typescript.default.SyntaxKind.NumberKeyword) {
-      return { type: "number", ...(0, import_xlr_utils.decorateNode)(node) };
+    if (node.kind === import_typescript3.default.SyntaxKind.NumberKeyword) {
+      return { type: "number", ...decorateNode(node) };
     }
-    if (node.kind === import_typescript.default.SyntaxKind.BooleanKeyword) {
-      return { type: "boolean", ...(0, import_xlr_utils.decorateNode)(node) };
+    if (node.kind === import_typescript3.default.SyntaxKind.BooleanKeyword) {
+      return { type: "boolean", ...decorateNode(node) };
     }
-    if (node.kind === import_typescript.default.SyntaxKind.UndefinedKeyword) {
-      return { type: "undefined", ...(0, import_xlr_utils.decorateNode)(node) };
+    if (node.kind === import_typescript3.default.SyntaxKind.UndefinedKeyword) {
+      return { type: "undefined", ...decorateNode(node) };
     }
-    if (node.kind === import_typescript.default.SyntaxKind.NeverKeyword) {
-      return { type: "never", ...(0, import_xlr_utils.decorateNode)(node) };
+    if (node.kind === import_typescript3.default.SyntaxKind.NeverKeyword) {
+      return { type: "never", ...decorateNode(node) };
     }
-    if (node.kind === import_typescript.default.SyntaxKind.ObjectKeyword) {
+    if (node.kind === import_typescript3.default.SyntaxKind.ObjectKeyword) {
       return {
         type: "object",
         properties: {},
         additionalProperties: AnyTypeNode,
-        ...(0, import_xlr_utils.decorateNode)(node)
+        ...decorateNode(node)
       };
     }
-    if (node.kind === import_typescript.default.SyntaxKind.VoidKeyword) {
+    if (node.kind === import_typescript3.default.SyntaxKind.VoidKeyword) {
       return {
         type: "void",
-        ...(0, import_xlr_utils.decorateNode)(node)
+        ...decorateNode(node)
       };
     }
-    if (import_typescript.default.isTemplateLiteralTypeNode(node)) {
+    if (import_typescript3.default.isTemplateLiteralTypeNode(node)) {
       let format;
       if (this.context.cache.convertedTemplates.has(node)) {
         format = this.context.cache.convertedTemplates.get(node);
       } else {
-        format = (0, import_xlr_utils.buildTemplateRegex)(node, this.context.typeChecker);
+        format = buildTemplateRegex(node, this.context.typeChecker);
         this.context.cache.convertedTemplates.set(node, format);
       }
       return {
@@ -281,14 +538,14 @@ var TsConverter = class {
         format
       };
     }
-    if (import_typescript.default.isArrayTypeNode(node)) {
+    if (import_typescript3.default.isArrayTypeNode(node)) {
       return {
         type: "array",
         elementType: this.convertTsTypeNode(node.elementType) ?? AnyTypeNode,
-        ...(0, import_xlr_utils.decorateNode)(node)
+        ...decorateNode(node)
       };
     }
-    if (import_typescript.default.isConditionalTypeNode(node)) {
+    if (import_typescript3.default.isConditionalTypeNode(node)) {
       const xlrNode = {
         type: "conditional",
         check: {
@@ -306,27 +563,27 @@ var TsConverter = class {
         return xlrNode;
       }
     }
-    if (import_typescript.default.isTypeReferenceNode(node)) {
+    if (import_typescript3.default.isTypeReferenceNode(node)) {
       return this.resolveRefNode(node);
     }
-    if (import_typescript.default.isTupleTypeNode(node)) {
+    if (import_typescript3.default.isTupleTypeNode(node)) {
       return {
         type: "tuple",
         ...this.tsTupleToType(node),
-        ...(0, import_xlr_utils.decorateNode)(node)
+        ...decorateNode(node)
       };
     }
-    if (import_typescript.default.isLiteralTypeNode(node)) {
+    if (import_typescript3.default.isLiteralTypeNode(node)) {
       return this.tsLiteralToType(node.literal);
     }
-    if (import_typescript.default.isTypeLiteralNode(node)) {
+    if (import_typescript3.default.isTypeLiteralNode(node)) {
       return {
         type: "object",
         ...this.tsObjectMembersToProperties(node),
-        ...(0, import_xlr_utils.decorateNode)(node)
+        ...decorateNode(node)
       };
     }
-    if (import_typescript.default.isFunctionTypeNode(node) || import_typescript.default.isFunctionDeclaration(node) || import_typescript.default.isArrowFunction(node)) {
+    if (import_typescript3.default.isFunctionTypeNode(node) || import_typescript3.default.isFunctionDeclaration(node) || import_typescript3.default.isArrowFunction(node)) {
       const parameters = node.parameters.map(
         (param) => {
           let typeNode;
@@ -351,11 +608,11 @@ var TsConverter = class {
         type: "function",
         parameters,
         returnType,
-        ...(0, import_xlr_utils.decorateNode)(node)
+        ...decorateNode(node)
       };
     }
-    if (import_typescript.default.isIndexedAccessTypeNode(node)) {
-      if (import_typescript.default.isTypeReferenceNode(node.objectType) && import_typescript.default.isLiteralTypeNode(node.indexType)) {
+    if (import_typescript3.default.isIndexedAccessTypeNode(node)) {
+      if (import_typescript3.default.isTypeReferenceNode(node.objectType) && import_typescript3.default.isLiteralTypeNode(node.indexType)) {
         const baseObject = this.convertTsTypeNode(node.objectType);
         const accessor = node.indexType.literal.getText().replace(/["']/g, "");
         if (!baseObject) {
@@ -378,10 +635,10 @@ var TsConverter = class {
         }
       }
       let queryNode = node.objectType;
-      if (import_typescript.default.isParenthesizedTypeNode(node.objectType)) {
+      if (import_typescript3.default.isParenthesizedTypeNode(node.objectType)) {
         queryNode = node.objectType.type;
       }
-      if (import_typescript.default.isTypeQueryNode(queryNode)) {
+      if (import_typescript3.default.isTypeQueryNode(queryNode)) {
         const elements = this.tsNodeToType(node.objectType);
         return {
           type: "or",
@@ -392,7 +649,7 @@ var TsConverter = class {
       const syntheticType = this.context.typeChecker.typeToTypeNode(
         effectiveType,
         node,
-        import_typescript.default.NodeBuilderFlags.NoTruncation
+        import_typescript3.default.NodeBuilderFlags.NoTruncation
       );
       if (syntheticType) {
         return this.tsNodeToType(syntheticType);
@@ -401,12 +658,12 @@ var TsConverter = class {
         `Error: could not solve IndexedAccessType: ${node.getFullText()}`
       );
     }
-    if (import_typescript.default.isTypeQueryNode(node)) {
+    if (import_typescript3.default.isTypeQueryNode(node)) {
       const effectiveType = this.context.typeChecker.getTypeAtLocation(node);
       const syntheticType = this.context.typeChecker.typeToTypeNode(
         effectiveType,
         node,
-        import_typescript.default.NodeBuilderFlags.NoTruncation
+        import_typescript3.default.NodeBuilderFlags.NoTruncation
       );
       if (syntheticType) {
         return this.tsNodeToType(syntheticType);
@@ -415,55 +672,55 @@ var TsConverter = class {
         `Error: could not synthesize type for ${node.getText()}`
       );
     }
-    if (import_typescript.default.isTypeOperatorNode(node)) {
+    if (import_typescript3.default.isTypeOperatorNode(node)) {
       return this.tsNodeToType(node.type);
     }
     this.context.throwError(
-      `Unimplemented type ${import_typescript.default.SyntaxKind[node.kind]} at ${node.getText()}`
+      `Unimplemented type ${import_typescript3.default.SyntaxKind[node.kind]} at ${node.getText()}`
     );
   }
   tsLiteralToType(node) {
-    if (import_typescript.default.isAsExpression(node)) {
+    if (import_typescript3.default.isAsExpression(node)) {
       return this.tsLiteralToType(node.expression);
     }
-    if (import_typescript.default.isNumericLiteral(node)) {
+    if (import_typescript3.default.isNumericLiteral(node)) {
       return {
         type: "number",
         const: Number(node.text),
-        ...(0, import_xlr_utils.decorateNode)(node)
+        ...decorateNode(node)
       };
     }
-    if (import_typescript.default.isStringLiteral(node)) {
+    if (import_typescript3.default.isStringLiteral(node)) {
       return {
         type: "string",
         const: node.text,
-        ...(0, import_xlr_utils.decorateNode)(node)
+        ...decorateNode(node)
       };
     }
-    if (node.kind === import_typescript.default.SyntaxKind.TrueKeyword) {
+    if (node.kind === import_typescript3.default.SyntaxKind.TrueKeyword) {
       return {
         type: "boolean",
         const: true,
-        ...(0, import_xlr_utils.decorateNode)(node)
+        ...decorateNode(node)
       };
     }
-    if (node.kind === import_typescript.default.SyntaxKind.FalseKeyword) {
+    if (node.kind === import_typescript3.default.SyntaxKind.FalseKeyword) {
       return {
         type: "boolean",
         const: false,
-        ...(0, import_xlr_utils.decorateNode)(node)
+        ...decorateNode(node)
       };
     }
-    if (node.kind === import_typescript.default.SyntaxKind.NullKeyword) {
-      return { type: "null", ...(0, import_xlr_utils.decorateNode)(node) };
+    if (node.kind === import_typescript3.default.SyntaxKind.NullKeyword) {
+      return { type: "null", ...decorateNode(node) };
     }
-    if (import_typescript.default.isPrefixUnaryExpression(node)) {
+    if (import_typescript3.default.isPrefixUnaryExpression(node)) {
       this.context.throwError("Prefix unary expressions not supported");
     }
-    if (import_typescript.default.isArrayLiteralExpression(node)) {
+    if (import_typescript3.default.isArrayLiteralExpression(node)) {
       const arrayElements = [];
       node.elements.forEach((element) => {
-        if (import_typescript.default.isSpreadElement(element)) {
+        if (import_typescript3.default.isSpreadElement(element)) {
           const arrayReference = this.resolveLiteralReference(
             element.expression
           );
@@ -478,20 +735,20 @@ var TsConverter = class {
         const: arrayElements
       };
     }
-    if (import_typescript.default.isObjectLiteralExpression(node)) {
+    if (import_typescript3.default.isObjectLiteralExpression(node)) {
       const ret = {
         type: "object",
         properties: {},
         additionalProperties: false
       };
       node.properties.forEach((property) => {
-        if (import_typescript.default.isPropertyAssignment(property) && property.name) {
+        if (import_typescript3.default.isPropertyAssignment(property) && property.name) {
           const propertyName = getPropertyNameText(property.name);
           ret.properties[propertyName] = {
             required: true,
             node: this.tsLiteralToType(property.initializer)
           };
-        } else if (import_typescript.default.isSpreadAssignment(property)) {
+        } else if (import_typescript3.default.isSpreadAssignment(property)) {
           const spreadValue = this.resolveLiteralReference(
             property.expression
           );
@@ -503,22 +760,22 @@ var TsConverter = class {
       });
       return ret;
     }
-    if (import_typescript.default.isIdentifier(node)) {
+    if (import_typescript3.default.isIdentifier(node)) {
       return this.resolveLiteralReference(node);
     }
     this.context.throwError(
-      `Literal type not understood ${import_typescript.default.SyntaxKind[node.kind]} at ${node.getText()}`
+      `Literal type not understood ${import_typescript3.default.SyntaxKind[node.kind]} at ${node.getText()}`
     );
   }
   resolveLiteralReference(expression) {
-    if (import_typescript.default.isIdentifier(expression)) {
+    if (import_typescript3.default.isIdentifier(expression)) {
       const symbol = this.context.typeChecker.getSymbolAtLocation(expression);
       let expressionReference = symbol?.declarations?.[0];
-      if (symbol && expressionReference && import_typescript.default.isImportSpecifier(expressionReference)) {
+      if (symbol && expressionReference && import_typescript3.default.isImportSpecifier(expressionReference)) {
         const referencedDeclaration = this.context.typeChecker.getAliasedSymbol(symbol);
         expressionReference = referencedDeclaration.declarations?.[0];
       }
-      if (expressionReference && import_typescript.default.isVariableDeclaration(expressionReference) && expressionReference.initializer) {
+      if (expressionReference && import_typescript3.default.isVariableDeclaration(expressionReference) && expressionReference.initializer) {
         return this.convertVariable(
           expressionReference.parent.parent
         );
@@ -532,7 +789,7 @@ var TsConverter = class {
     );
   }
   resolveFunctionCall(functionCall, document) {
-    if (import_typescript.default.isArrowFunction(functionCall)) {
+    if (import_typescript3.default.isArrowFunction(functionCall)) {
       const declaredReturnType = functionCall.parent.type;
       if (declaredReturnType) {
         return this.tsNodeToType(declaredReturnType);
@@ -544,7 +801,7 @@ var TsConverter = class {
       document,
       void 0
     );
-    if (import_typescript.default.isArrowFunction(functionCall)) {
+    if (import_typescript3.default.isArrowFunction(functionCall)) {
       const syntheticWithParameters = {
         ...syntheticNode,
         parameters: functionCall.parameters
@@ -552,7 +809,7 @@ var TsConverter = class {
       syntheticNode = syntheticWithParameters;
     }
     if (syntheticNode) {
-      if (import_typescript.default.isTypeReferenceNode(syntheticNode) && import_typescript.default.isIdentifier(syntheticNode.typeName)) {
+      if (import_typescript3.default.isTypeReferenceNode(syntheticNode) && import_typescript3.default.isIdentifier(syntheticNode.typeName)) {
         const { typeName } = syntheticNode;
         if (this.context.customPrimitives.includes(typeName.text)) {
           return this.makeBasicRefNode(syntheticNode);
@@ -560,7 +817,7 @@ var TsConverter = class {
         const declarationSymbol = typeName.symbol;
         if (declarationSymbol && declarationSymbol.declarations?.[0]) {
           const declaration = declarationSymbol.declarations[0];
-          if (import_typescript.default.isTypeAliasDeclaration(declaration) || import_typescript.default.isInterfaceDeclaration(declaration)) {
+          if (import_typescript3.default.isTypeAliasDeclaration(declaration) || import_typescript3.default.isInterfaceDeclaration(declaration)) {
             return this.convertDeclaration(declaration);
           }
         }
@@ -580,18 +837,18 @@ var TsConverter = class {
       additionalProperties: false
     };
     node.members.forEach((member) => {
-      if (import_typescript.default.isPropertySignature(member) && member.type) {
+      if (import_typescript3.default.isPropertySignature(member) && member.type) {
         const name = getPropertyNameText(member.name);
         ret.properties[name] = {
-          required: !(0, import_xlr_utils.isOptionalProperty)(member),
+          required: !isOptionalProperty(member),
           node: {
             ...this.convertTsTypeNode(member.type) ?? AnyTypeNode,
-            ...(0, import_xlr_utils.decorateNode)(member)
+            ...decorateNode(member)
           }
         };
-      } else if (import_typescript.default.isIndexSignatureDeclaration(member)) {
+      } else if (import_typescript3.default.isIndexSignatureDeclaration(member)) {
         const param = member.parameters[0];
-        if (param.type?.kind !== import_typescript.default.SyntaxKind.StringKeyword) {
+        if (param.type?.kind !== import_typescript3.default.SyntaxKind.StringKeyword) {
           this.context.throwError(
             "Will not convert non-string index signature"
           );
@@ -605,13 +862,13 @@ var TsConverter = class {
     if (node.elements.length === 0) {
       return { elementTypes: [], additionalItems: false, minItems: 0 };
     }
-    const hasRest = import_typescript.default.isRestTypeNode(node.elements[node.elements.length - 1]);
+    const hasRest = import_typescript3.default.isRestTypeNode(node.elements[node.elements.length - 1]);
     const [elements, rest] = hasRest ? [
       node.elements.slice(0, node.elements.length - 1),
       node.elements[node.elements.length - 1]
     ] : [[...node.elements], void 0];
     const elementTypes = elements.map((element) => {
-      if (import_typescript.default.isNamedTupleMember(element)) {
+      if (import_typescript3.default.isNamedTupleMember(element)) {
         let typeNode;
         if (element.type) {
           typeNode = this.convertTsTypeNode(element.type);
@@ -623,8 +880,8 @@ var TsConverter = class {
         };
       }
       return {
-        type: this.convertTsTypeNode((0, import_xlr_utils.tsStripOptionalType)(element)),
-        optional: import_typescript.default.isOptionalTypeNode(element)
+        type: this.convertTsTypeNode(tsStripOptionalType(element)),
+        optional: import_typescript3.default.isOptionalTypeNode(element)
       };
     });
     const additionalItems = rest ? this.convertTsTypeNode(rest.type.elementType) ?? AnyTypeNode : false;
@@ -658,7 +915,7 @@ var TsConverter = class {
             );
           }
           let parentInterface;
-          if (import_typescript.default.isTypeLiteralNode(parentDeclarations?.[0]) && import_typescript.default.isTypeAliasDeclaration(parentDeclarations?.[0].parent)) {
+          if (import_typescript3.default.isTypeLiteralNode(parentDeclarations?.[0]) && import_typescript3.default.isTypeAliasDeclaration(parentDeclarations?.[0].parent)) {
             parentInterface = parentDeclarations?.[0].parent;
           } else {
             parentInterface = parentDeclarations?.[0];
@@ -728,8 +985,8 @@ var TsConverter = class {
       } else if (tp.default) {
         typeToProcess = tp.default;
       } else {
-        typeToProcess = import_typescript.default.factory.createKeywordTypeNode(
-          import_typescript.default.SyntaxKind.AnyKeyword
+        typeToProcess = import_typescript3.default.factory.createKeywordTypeNode(
+          import_typescript3.default.SyntaxKind.AnyKeyword
         );
       }
       const processedNodeType = this.convertTsTypeNode(typeToProcess);
@@ -762,14 +1019,14 @@ var TsConverter = class {
   resolveRefNode(node) {
     let refName;
     let namespace;
-    if (node.typeName.kind === import_typescript.default.SyntaxKind.QualifiedName) {
+    if (node.typeName.kind === import_typescript3.default.SyntaxKind.QualifiedName) {
       namespace = node.typeName.left.getText();
       refName = node.typeName.right.getText();
     } else {
       refName = node.typeName.text;
     }
-    if ((0, import_xlr_utils.isTypeReferenceGeneric)(node, this.context.typeChecker)) {
-      if (import_typescript.default.isIndexedAccessTypeNode(node.parent)) {
+    if (isTypeReferenceGeneric(node, this.context.typeChecker)) {
+      if (import_typescript3.default.isIndexedAccessTypeNode(node.parent)) {
         const genericSymbol = this.context.typeChecker.getSymbolAtLocation(
           node.typeName
         );
@@ -787,14 +1044,14 @@ var TsConverter = class {
         }
         return AnyTypeNode;
       }
-      return { type: "ref", ref: node.getText(), ...(0, import_xlr_utils.decorateNode)(node) };
+      return { type: "ref", ref: node.getText(), ...decorateNode(node) };
     }
     if (refName === "Array") {
       const typeArgs = node.typeArguments;
       return {
         type: "array",
         elementType: typeArgs ? this.convertTsTypeNode(typeArgs[0]) ?? AnyTypeNode : AnyTypeNode,
-        ...(0, import_xlr_utils.decorateNode)(node)
+        ...decorateNode(node)
       };
     }
     if (refName === "Record") {
@@ -804,17 +1061,17 @@ var TsConverter = class {
         type: "record",
         keyType: this.convertTsTypeNode(indexType) ?? AnyTypeNode,
         valueType: this.convertTsTypeNode(valueType) ?? AnyTypeNode,
-        ...(0, import_xlr_utils.decorateNode)(node)
+        ...decorateNode(node)
       };
     }
     if (isMappedTypeNode(refName)) {
       return this.makeMappedType(refName, node);
     }
-    if ((0, import_xlr_utils.isTypeScriptLibType)(node, this.context.typeChecker)) {
+    if (isTypeScriptLibType(node, this.context.typeChecker)) {
       return this.makeBasicRefNode(node);
     }
     if (!this.context.customPrimitives.includes(refName)) {
-      const typeInfo = (0, import_xlr_utils.getReferencedType)(node, this.context.typeChecker);
+      const typeInfo = getReferencedType(node, this.context.typeChecker);
       if (typeInfo) {
         const convertedType = this.convertTopLevelNode(typeInfo.declaration);
         const genericParams = typeInfo.declaration.typeParameters;
@@ -867,7 +1124,7 @@ var TsConverter = class {
         return (0, import_xlr_utils.applyPickOrOmitToNodeType)(
           baseObj,
           refName,
-          (0, import_xlr_utils.getStringLiteralsFromUnion)(modifiers)
+          getStringLiteralsFromUnion(modifiers)
         );
       }
     }
@@ -884,7 +1141,7 @@ var TsConverter = class {
     if (node.typeArguments) {
       node.typeArguments.forEach((typeArg) => {
         let convertedNode;
-        if ((0, import_xlr_utils.isTopLevelDeclaration)(typeArg)) {
+        if (isTopLevelDeclaration(typeArg)) {
           convertedNode = this.convertDeclaration(typeArg);
         } else {
           convertedNode = this.convertTsTypeNode(typeArg);
@@ -899,10 +1156,10 @@ var TsConverter = class {
       });
     }
     let ref;
-    if (import_typescript.default.isTypeReferenceNode(node)) {
-      if (node.typeName.kind === import_typescript.default.SyntaxKind.QualifiedName) {
+    if (import_typescript3.default.isTypeReferenceNode(node)) {
+      if (node.typeName.kind === import_typescript3.default.SyntaxKind.QualifiedName) {
         ref = `${node.typeName.left.getText()}.${node.typeName.right.getText()}`;
-      } else if (node.pos === -1 && import_typescript.default.isIdentifier(node.typeName)) {
+      } else if (node.pos === -1 && import_typescript3.default.isIdentifier(node.typeName)) {
         ref = node.typeName.text;
       } else {
         ref = node.getText();
@@ -913,7 +1170,7 @@ var TsConverter = class {
     return {
       type: "ref",
       ref,
-      ...(0, import_xlr_utils.decorateNode)(node),
+      ...decorateNode(node),
       genericArguments: genericArgs.length > 0 ? genericArgs : void 0
     };
   }
@@ -921,7 +1178,7 @@ var TsConverter = class {
 
 // ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/ts/xlr-to-ts.ts
 var import_xlr_utils2 = require("@xlr-lib/xlr-utils");
-var import_typescript2 = __toESM(require("typescript"));
+var import_typescript4 = __toESM(require("typescript"));
 var templateTokenize = /(?=true\|false|\.\*|\[0-9]\*)/gm;
 var tokenSplit = /(?<=true\|false|\.\*|\[0-9]\*)/gm;
 var TSWriter = class {
@@ -930,7 +1187,7 @@ var TSWriter = class {
   additionalTypes;
   constructor(factory) {
     this.context = {
-      factory: factory ?? import_typescript2.default.factory,
+      factory: factory ?? import_typescript4.default.factory,
       throwError: (message) => {
         throw new ConversionError(message);
       }
@@ -958,7 +1215,7 @@ var TSWriter = class {
       const refName = type.extends.ref.split("<")[0];
       customPrimitiveHeritageClass = [
         this.context.factory.createHeritageClause(
-          import_typescript2.default.SyntaxKind.ExtendsKeyword,
+          import_typescript4.default.SyntaxKind.ExtendsKeyword,
           [
             this.context.factory.createExpressionWithTypeArguments(
               this.context.factory.createIdentifier(refName),
@@ -980,7 +1237,7 @@ var TSWriter = class {
       });
     }
     let finalNode;
-    if (import_typescript2.default.isTypeLiteralNode(tsNode)) {
+    if (import_typescript4.default.isTypeLiteralNode(tsNode)) {
       finalNode = this.makeInterfaceDeclaration(
         typeName,
         tsNode.members,
@@ -1093,35 +1350,35 @@ var TSWriter = class {
     switch (xlrNode.type) {
       case "string":
         return this.context.factory.createKeywordTypeNode(
-          import_typescript2.default.SyntaxKind.StringKeyword
+          import_typescript4.default.SyntaxKind.StringKeyword
         );
       case "number":
         return this.context.factory.createKeywordTypeNode(
-          import_typescript2.default.SyntaxKind.NumberKeyword
+          import_typescript4.default.SyntaxKind.NumberKeyword
         );
       case "boolean":
         return this.context.factory.createKeywordTypeNode(
-          import_typescript2.default.SyntaxKind.BooleanKeyword
+          import_typescript4.default.SyntaxKind.BooleanKeyword
         );
       case "any":
         return this.context.factory.createKeywordTypeNode(
-          import_typescript2.default.SyntaxKind.AnyKeyword
+          import_typescript4.default.SyntaxKind.AnyKeyword
         );
       case "unknown":
         return this.context.factory.createKeywordTypeNode(
-          import_typescript2.default.SyntaxKind.UnknownKeyword
+          import_typescript4.default.SyntaxKind.UnknownKeyword
         );
       case "never":
         return this.context.factory.createKeywordTypeNode(
-          import_typescript2.default.SyntaxKind.NeverKeyword
+          import_typescript4.default.SyntaxKind.NeverKeyword
         );
       case "undefined":
         return this.context.factory.createKeywordTypeNode(
-          import_typescript2.default.SyntaxKind.UndefinedKeyword
+          import_typescript4.default.SyntaxKind.UndefinedKeyword
         );
       case "void":
         return this.context.factory.createKeywordTypeNode(
-          import_typescript2.default.SyntaxKind.VoidKeyword
+          import_typescript4.default.SyntaxKind.VoidKeyword
         );
       default:
         this.context.throwError(
@@ -1155,7 +1412,7 @@ var TSWriter = class {
           return this.context.factory.createNamedTupleMember(
             void 0,
             this.context.factory.createIdentifier(e.name),
-            e.optional ? this.context.factory.createToken(import_typescript2.default.SyntaxKind.QuestionToken) : void 0,
+            e.optional ? this.context.factory.createToken(import_typescript4.default.SyntaxKind.QuestionToken) : void 0,
             this.convertTypeNode(e.type)
           );
         }
@@ -1171,12 +1428,12 @@ var TSWriter = class {
           void 0,
           void 0,
           e.name,
-          e.optional ? this.context.factory.createToken(import_typescript2.default.SyntaxKind.QuestionToken) : void 0,
+          e.optional ? this.context.factory.createToken(import_typescript4.default.SyntaxKind.QuestionToken) : void 0,
           this.convertTypeNode(e.type),
           e.default ? this.createLiteralTypeNode(e.default) : void 0
         );
       }),
-      xlrNode.returnType ? this.convertTypeNode(xlrNode.returnType) : this.context.factory.createToken(import_typescript2.default.SyntaxKind.VoidKeyword)
+      xlrNode.returnType ? this.convertTypeNode(xlrNode.returnType) : this.context.factory.createToken(import_typescript4.default.SyntaxKind.VoidKeyword)
     );
   }
   createRecordNode(xlrNode) {
@@ -1208,7 +1465,7 @@ var TSWriter = class {
             void 0,
             // modifiers
             name,
-            required ? void 0 : this.context.factory.createToken(import_typescript2.default.SyntaxKind.QuestionToken),
+            required ? void 0 : this.context.factory.createToken(import_typescript4.default.SyntaxKind.QuestionToken),
             this.convertTypeNode(node)
           ),
           node
@@ -1230,7 +1487,7 @@ var TSWriter = class {
               void 0,
               // question token
               this.context.factory.createKeywordTypeNode(
-                import_typescript2.default.SyntaxKind.StringKeyword
+                import_typescript4.default.SyntaxKind.StringKeyword
               )
             )
           ],
@@ -1257,11 +1514,11 @@ var TSWriter = class {
         const [regexSegment, stringSegment = ""] = segments.split(tokenSplit);
         let regexTemplateType;
         if (regexSegment === ".*") {
-          regexTemplateType = import_typescript2.default.SyntaxKind.StringKeyword;
+          regexTemplateType = import_typescript4.default.SyntaxKind.StringKeyword;
         } else if (regexSegment === "[0-9]*") {
-          regexTemplateType = import_typescript2.default.SyntaxKind.NumberKeyword;
+          regexTemplateType = import_typescript4.default.SyntaxKind.NumberKeyword;
         } else if (regexSegment === "true|false") {
-          regexTemplateType = import_typescript2.default.SyntaxKind.BooleanKeyword;
+          regexTemplateType = import_typescript4.default.SyntaxKind.BooleanKeyword;
         } else {
           this.context.throwError(
             `Can't make template literal type from regex ${regexSegment}`
@@ -1305,9 +1562,9 @@ ${comment.split("\n").map((s) => ` * ${s}`).join("\n")}
     } else {
       comment = `* ${comment} `;
     }
-    return import_typescript2.default.addSyntheticLeadingComment(
+    return import_typescript4.default.addSyntheticLeadingComment(
       tsNode,
-      import_typescript2.default.SyntaxKind.MultiLineCommentTrivia,
+      import_typescript4.default.SyntaxKind.MultiLineCommentTrivia,
       comment,
       true
     );
@@ -1325,7 +1582,7 @@ ${comment.split("\n").map((s) => ` * ${s}`).join("\n")}
   makeInterfaceDeclaration(name, node, generics, heritageClass) {
     return this.context.factory.createInterfaceDeclaration(
       this.context.factory.createModifiersFromModifierFlags(
-        import_typescript2.default.ModifierFlags.Export
+        import_typescript4.default.ModifierFlags.Export
       ),
       this.context.factory.createIdentifier(name),
       generics,
@@ -1338,7 +1595,7 @@ ${comment.split("\n").map((s) => ` * ${s}`).join("\n")}
   makeTypeDeclaration(name, node, generics) {
     return this.context.factory.createTypeAliasDeclaration(
       this.context.factory.createModifiersFromModifierFlags(
-        import_typescript2.default.ModifierFlags.Export
+        import_typescript4.default.ModifierFlags.Export
       ),
       this.context.factory.createIdentifier(name),
       generics,
@@ -1347,9 +1604,67 @@ ${comment.split("\n").map((s) => ` * ${s}`).join("\n")}
     );
   }
 };
+function exportTypesToTypeScript(typesToExport, importMap) {
+  const writer = new TSWriter();
+  const referencedImports = /* @__PURE__ */ new Set();
+  const exportedTypes = /* @__PURE__ */ new Map();
+  const printer = import_typescript4.default.createPrinter({ newLine: import_typescript4.default.NewLineKind.LineFeed });
+  let resultFile = import_typescript4.default.createSourceFile(
+    "output.d.ts",
+    "",
+    import_typescript4.default.ScriptTarget.ES2017,
+    false,
+    import_typescript4.default.ScriptKind.TS
+  );
+  typesToExport.forEach((typeNode) => {
+    const { type, referencedTypes, additionalTypes } = writer.convertNamedType(typeNode);
+    exportedTypes.set(typeNode.name, type);
+    additionalTypes?.forEach(
+      (additionalType, name) => exportedTypes.set(name, additionalType)
+    );
+    referencedTypes?.forEach(
+      (referencedType) => referencedImports.add(referencedType)
+    );
+  });
+  const typesToPrint = [];
+  exportedTypes.forEach(
+    (type) => typesToPrint.push(
+      printer.printNode(import_typescript4.default.EmitHint.Unspecified, type, resultFile)
+    )
+  );
+  importMap.forEach((imports, packageName) => {
+    const applicableImports = imports.filter((i) => referencedImports.has(i));
+    if (applicableImports.length === 0) return;
+    resultFile = import_typescript4.default.factory.updateSourceFile(resultFile, [
+      import_typescript4.default.factory.createImportDeclaration(
+        /* modifiers */
+        void 0,
+        import_typescript4.default.factory.createImportClause(
+          false,
+          void 0,
+          import_typescript4.default.factory.createNamedImports(
+            applicableImports.map(
+              (i) => import_typescript4.default.factory.createImportSpecifier(
+                false,
+                void 0,
+                import_typescript4.default.factory.createIdentifier(i)
+              )
+            )
+          )
+        ),
+        import_typescript4.default.factory.createStringLiteral(packageName)
+      ),
+      ...resultFile.statements
+    ]);
+  });
+  const headerText = printer.printFile(resultFile);
+  const nodeText = typesToPrint.join("\n");
+  return `${headerText}
+${nodeText}`;
+}
 
 // ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/helpers/converter.ts
-var import_typescript3 = __toESM(require("typescript"));
+var import_typescript5 = __toESM(require("typescript"));
 var import_path2 = __toESM(require("path"));
 var import_fs2 = __toESM(require("fs"));
 
@@ -1386,7 +1701,7 @@ function writeManifest(capabilities, outputDirectory) {
 
 // ../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/converters/src/helpers/converter.ts
 function converter(sourceFile, outputDirectory, customPrimitives, tsOptions = {}) {
-  const program = import_typescript3.default.createProgram([sourceFile], tsOptions);
+  const program = import_typescript5.default.createProgram([sourceFile], tsOptions);
   import_fs2.default.mkdirSync(outputDirectory, { recursive: true });
   const checker = program.getTypeChecker();
   const converter2 = new TsConverter(checker, customPrimitives);
@@ -1415,6 +1730,7 @@ function converter(sourceFile, outputDirectory, customPrimitives, tsOptions = {}
   TSWriter,
   TsConverter,
   converter,
+  exportTypesToTypeScript,
   writeManifest
 });
 //# sourceMappingURL=index.cjs.map