@osdk/generator 1.5.0 → 1.7.0

package/build/js/index.cjs

@@ -3,6 +3,7 @@
 var path15 = require('path');
 var prettier = require('prettier');
 var organizeImports = require('prettier-plugin-organize-imports');
+var generatorConverters = require('@osdk/generator-converters');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -804,32 +805,12 @@ function wireActionTypeV2ToSdkActionDefinition(input) {
   };
 }
 function wireActionParameterV2ToSdkParameterDefinition(value) {
-  switch (value.dataType.type) {
-    case "string":
-    case "boolean":
-    case "object":
-    case "attachment":
-    case "date":
-    case "double":
-    case "integer":
-    case "long":
-    case "objectSet":
-    case "timestamp":
-    case "marking":
-      return {
-        multiplicity: false,
-        type: actionPropertyToSdkPropertyDefinition(value.dataType),
-        nullable: value.required ? false : true,
-        description: value.description
-      };
-    case "array":
-      return {
-        multiplicity: true,
-        type: actionPropertyToSdkPropertyDefinition(value.dataType.subType),
-        nullable: value.required ? false : true,
-        description: value.description
-      };
-  }
+  return {
+    multiplicity: value.dataType.type === "array",
+    type: actionPropertyToSdkPropertyDefinition(value.dataType.type === "array" ? value.dataType.subType : value.dataType),
+    nullable: !value.required,
+    description: value.description
+  };
 }
 function actionPropertyToSdkPropertyDefinition(parameterType) {
   switch (parameterType.type) {
@@ -884,6 +865,80 @@ function deleteUndefineds(obj) {
   return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== void 0));
 }
 
+// src/util/stringify.ts
+var defaultCustomizer = (value, defaultValueFormatter, key, defaultKeyFormatter) => {
+  return [defaultKeyFormatter(key), defaultValueFormatter(value)];
+};
+function stringify(obj, customizer = {}, separator = ",\n") {
+  const defaultKeyFormatter = (key) => `${JSON.stringify(key)}`;
+  const entries = [];
+  const sortedKeys = Object.keys(obj).sort((a, b) => a.localeCompare(b));
+  for (const key of sortedKeys) {
+    const value = obj[key];
+    const res = (customizer[key] ?? customizer["*"] ?? defaultCustomizer)(value, (value2) => JSON.stringify(value2, null, 2), key, defaultKeyFormatter);
+    if (res) {
+      if (typeof res === "string") {
+        entries.push(`${defaultKeyFormatter(key)}: ${res}`);
+      } else {
+        entries.push(`${res[0]}: ${res[1]}`);
+      }
+    }
+  }
+  return entries.join(separator);
+}
+
+// src/shared/wireObjectTypeV2ToSdkObjectConst.ts
+function getObjectDefIdentifier(name, v2) {
+  return v2 ? name : `${name}Def`;
+}
+function wireObjectTypeV2ToSdkObjectConst(object, importExt, v2 = false) {
+  const uniqueLinkTargetTypes = new Set(object.linkTypes.map((a) => a.objectTypeApiName));
+  const definition = deleteUndefineds(generatorConverters.wireObjectTypeFullMetadataToSdkObjectTypeDefinition(object, v2));
+  const objectDefIdentifier = getObjectDefIdentifier(object.objectType.apiName, v2);
+  function getV1Types() {
+    return `
+      export interface ${objectDefIdentifier} extends ObjectTypeDefinition<"${object.objectType.apiName}", ${object.objectType.apiName}> {
+        ${stringify(definition, {
+      links: (_value) => `{
+          ${stringify(definition.links, {
+        "*": (definition2) => `ObjectTypeLinkDefinition<${getObjectDefIdentifier(definition2.targetType, v2)}, ${definition2.multiplicity}>`
+      })}
+        }`
+    })}
+      }
+    `;
+  }
+  function getV2Types() {
+    return `
+      export interface ${objectDefIdentifier} extends ObjectTypeDefinition<"${object.objectType.apiName}", ${object.objectType.apiName}> {
+        ${stringify(definition, {
+      type: () => void 0,
+      apiName: () => void 0,
+      links: (_value) => `{
+          ${stringify(definition.links, {
+        "*": (definition2) => `ObjectTypeLinkDefinition<${getObjectDefIdentifier(definition2.targetType, v2)}, ${definition2.multiplicity}>`
+      })}
+        }`,
+      properties: (_value) => `{
+          ${stringify(definition.properties, {
+        "*": (propertyDefinition) => `PropertyDef<"${propertyDefinition.type}", "${propertyDefinition.nullable ? "nullable" : "non-nullable"}", "${propertyDefinition.multiplicity ? "array" : "single"}">`
+      })}
+        }`
+    })}
+      }
+
+    `;
+  }
+  const imports = Array.from(uniqueLinkTargetTypes).filter((type) => type !== definition.apiName).map((type) => `import type { ${getObjectDefIdentifier(type, v2)} } from "./${type}${importExt}";`);
+  return `${imports.join("\n")}
+
+    ${v2 ? getV2Types() : getV1Types()}
+
+    export const ${object.objectType.apiName}: ${objectDefIdentifier} = {
+      ${stringify(definition)}
+    };`;
+}
+
 // src/util/reservedKeywords.ts
 var reservedKeywords = /* @__PURE__ */ new Set(["break", "case", "catch", "class", "const", "continue", "debugger", "default", "delete", "do", "else", "enum", "export", "extends", "false", "finally", "for", "function", "if", "import", "in", "instanceof", "new", "null", "return", "super", "switch", "this", "throw", "true", "try", "typeof", "var", "void", "while", "with", "implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"]);
 function isReservedKeyword(name) {
@@ -933,7 +988,7 @@ function wirePropertyTypeV2ToTypeScriptType(property) {
     case "date":
       return "LocalDate";
     case "decimal":
-      return "number";
+      return "string";
     case "double":
       return "number";
     case "float":
@@ -943,7 +998,7 @@ function wirePropertyTypeV2ToTypeScriptType(property) {
     case "geoshape":
       return "GeoShape";
     case "long":
-      return "number";
+      return "string";
     case "short":
       return "number";
     case "timestamp":
@@ -966,9 +1021,6 @@ function getDescriptionIfPresent(description, includeNewline) {
 }
 
 // src/v1.1/generatePerActionDataFiles.ts
-function stringifyWithoutOuterBraces(obj) {
-  return JSON.stringify(obj, null, 2).replace(/^\{\n/, "").replace(/\n\}$/, "");
-}
 async function generatePerActionDataFiles(ontology, fs, outDir, importExt, v2) {
   await fs.mkdir(outDir, {
     recursive: true
@@ -986,30 +1038,30 @@ async function generatePerActionDataFiles(ontology, fs, outDir, importExt, v2) {
     const paramsIdentifier = `${action.apiName}$Params`;
     function createParamsDef() {
       const entries = Object.entries(parameters);
+      entries.sort((a, b) => a[0].localeCompare(b[0]));
       if (entries.length === 0) {
         return `// Represents the definition of the parameters for the action
           export type ${paramsDefIdentifier} = Record<string, never>;`;
       }
       return `// Represents the definition of the parameters for the action
         export type ${paramsDefIdentifier} = {
-          ${Object.entries(parameters).map(([key, value]) => {
-        const {
-          type,
-          ...remain
-        } = value;
-        let q;
-        if (typeof type === "string") {
-          q = JSON.stringify(type);
-        } else if (type.type === "object") {
-          q = `ObjectActionDataType<"${type.object}", ${type.object}Def>`;
-        } else if (type.type === "objectSet") {
-          q = `ObjectSetActionDataType<"${type.objectSet}", ${type.objectSet}Def>`;
-        }
+          ${entries.map(([key, value]) => {
         return `"${key}": {
-              type: ${q};
-              ${stringifyWithoutOuterBraces(remain)}
+                ${stringify(value, {
+          description: (value2, d) => value2 ? d(value2) : void 0,
+          // trick to remove undefineds
+          type: (type) => {
+            if (typeof type === "string") {
+              return JSON.stringify(type);
+            } else if (type.type === "object") {
+              return `ObjectActionDataType<"${type.object}", ${getObjectDefIdentifier(type.object, v2)}>`;
+            } else if (type.type === "objectSet") {
+              return `ObjectSetActionDataType<"${type.objectSet}", ${getObjectDefIdentifier(type.objectSet, v2)}>`;
             }
-            `;
+            return void 0;
+          }
+        })}
+            }`;
       }).join(";\n")}
         }`;
     }
@@ -1032,7 +1084,7 @@ async function generatePerActionDataFiles(ontology, fs, outDir, importExt, v2) {
           
           // Represents the definition of the action
           export interface ${actionDefIdentifier} extends ActionDefinition<"${action.apiName}", ${uniqueApiNamesString}, ${action.apiName}>{
-          ${Object.entries(actionDefSansParameters).map(([key, value]) => {
+          ${Object.entries(actionDefSansParameters).sort((a, b) => a[0].localeCompare(b[0])).map(([key, value]) => {
         return `${key}: ${JSON.stringify(value)};`;
       }).join("\n")}
           parameters: ${paramsDefIdentifier}
@@ -1047,8 +1099,8 @@ async function generatePerActionDataFiles(ontology, fs, outDir, importExt, v2) {
     const referencedObjectDefs = /* @__PURE__ */ new Set();
     for (const p of Object.values(action.parameters)) {
       if (p.dataType.type === "object" || p.dataType.type === "objectSet") {
-        referencedObjectDefs.add(p.dataType.objectApiName + "Def");
-        referencedObjectDefs.add(p.dataType.objectTypeApiName + "Def");
+        referencedObjectDefs.add(getObjectDefIdentifier(p.dataType.objectApiName, v2));
+        referencedObjectDefs.add(getObjectDefIdentifier(p.dataType.objectTypeApiName, v2));
       }
     }
     const importObjects = referencedObjectDefs.size > 0 ? `import type {${[...referencedObjectDefs].join(",")}} from "../objects${importExt}";` : "";
@@ -1065,6 +1117,7 @@ async function generatePerActionDataFiles(ontology, fs, outDir, importExt, v2) {
   }));
   await fs.writeFile(path15__namespace.default.join(outDir, `index.ts`), await formatTs(`
       ${Object.values(ontology.actionTypes).map((action) => `export {${action.apiName}} from "./${action.apiName}${importExt}";`).join("\n")}
+    ${Object.keys(ontology.actionTypes).length === 0 ? "export {};" : ""}
       `));
 }
 function extractReferencedObjectsFromAction(actionType) {
@@ -1106,157 +1159,6 @@ function extractReferencedObjectsFromActionParameter(actionParameter) {
       return void 0;
   }
 }
-
-// src/shared/wirePropertyV2ToSdkPrimaryKeyTypeDefinition.ts
-function wirePropertyV2ToSdkPrimaryKeyTypeDefinition(input) {
-  switch (input.dataType.type) {
-    case "integer":
-    case "double":
-    case "string":
-    case "boolean":
-    case "attachment":
-    case "byte":
-    case "decimal":
-    case "float":
-    case "geopoint":
-    case "geoshape":
-    case "long":
-    case "short": {
-      return input.dataType.type;
-    }
-    case "date": {
-      return "datetime";
-    }
-    case "timestamp": {
-      return "timestamp";
-    }
-    case "timeseries":
-    case "array":
-    case "marking":
-      throw new Error(`Type not supported for primaryKey: ${input.dataType.type}`);
-    default:
-      input.dataType;
-      throw new Error(`Unknown type encountered for primaryKey: ${input.dataType}`);
-  }
-}
-
-// src/shared/wirePropertyV2ToSdkPropertyDefinition.ts
-function wirePropertyV2ToSdkPropertyDefinition(input, isNullable = true) {
-  switch (input.dataType.type) {
-    case "integer":
-    case "string":
-    case "byte":
-    case "decimal":
-    case "double":
-    case "float":
-    case "long":
-    case "short":
-    case "boolean":
-    case "date":
-    case "attachment":
-    case "geopoint":
-    case "geoshape":
-    case "timestamp":
-    case "timeseries":
-    case "marking":
-      return {
-        multiplicity: false,
-        description: input.description,
-        type: objectPropertyTypeToSdkPropertyDefinition(input.dataType),
-        nullable: isNullable
-      };
-    case "array": {
-      return {
-        multiplicity: true,
-        description: input.description,
-        type: objectPropertyTypeToSdkPropertyDefinition(input.dataType),
-        nullable: true
-      };
-    }
-    default:
-      input.dataType;
-      throw new Error(`Unexpected data type ${JSON.stringify(input.dataType)}`);
-  }
-}
-function objectPropertyTypeToSdkPropertyDefinition(propertyType) {
-  switch (propertyType.type) {
-    case "integer":
-    case "string":
-    case "byte":
-    case "decimal":
-    case "double":
-    case "float":
-    case "long":
-    case "short":
-    case "boolean":
-    case "attachment":
-    case "geopoint":
-    case "geoshape":
-    case "timestamp":
-    case "marking":
-      return propertyType.type;
-    case "date":
-      return "datetime";
-    case "array":
-      return objectPropertyTypeToSdkPropertyDefinition(propertyType.subType);
-    case "timeseries":
-      if (propertyType.itemType.type === "string") {
-        return "stringTimeseries";
-      }
-      return "numericTimeseries";
-    default:
-      throw new Error(`Unexecpected data type ${JSON.stringify(propertyType)}`);
-  }
-}
-
-// src/shared/wireObjectTypeV2ToSdkObjectDefinition.ts
-function wireObjectTypeV2ToSdkObjectDefinition(objectTypeWithLink, v2) {
-  if (objectTypeWithLink.objectType.properties[objectTypeWithLink.objectType.primaryKey] === void 0) {
-    throw new Error(`Primary key ${objectTypeWithLink.objectType.primaryKey} not found in ${objectTypeWithLink.objectType.apiName}`);
-  }
-  return {
-    type: "object",
-    apiName: objectTypeWithLink.objectType.apiName,
-    description: objectTypeWithLink.objectType.description,
-    primaryKeyType: wirePropertyV2ToSdkPrimaryKeyTypeDefinition(objectTypeWithLink.objectType.properties[objectTypeWithLink.objectType.primaryKey]),
-    links: Object.fromEntries(objectTypeWithLink.linkTypes.map((linkType) => {
-      return [linkType.apiName, {
-        multiplicity: linkType.cardinality === "MANY",
-        targetType: linkType.objectTypeApiName
-      }];
-    })),
-    properties: Object.fromEntries(Object.entries(objectTypeWithLink.objectType.properties).map(([key, value]) => [key, wirePropertyV2ToSdkPropertyDefinition(value, !(v2 && objectTypeWithLink.objectType.primaryKey === key))]))
-  };
-}
-
-// src/shared/wireObjectTypeV2ToSdkObjectConst.ts
-function wireObjectTypeV2ToSdkObjectConst(object, importExt, v2 = false) {
-  const uniqueLinkTargetTypes = new Set(object.linkTypes.map((a) => a.objectTypeApiName));
-  const definition = wireObjectTypeV2ToSdkObjectDefinition(object, v2);
-  const imports = Array.from(uniqueLinkTargetTypes).filter((type) => type !== definition.apiName).map((type) => `import type { ${type}Def } from "./${type}${importExt}";`);
-  return `
-  ${imports.join("\n")}
-    export interface ${object.objectType.apiName}Def extends ObjectTypeDefinition<"${object.objectType.apiName}"> {
-      type: "${definition.type}",
-      apiName: "${definition.apiName}",
-      ${definition.description != null ? `description: ${JSON.stringify(definition.description)},` : ""}
-      primaryKeyType: ${JSON.stringify(definition.primaryKeyType)},
-      links: {${Object.entries(definition.links).map(([linkApiName, definition2]) => `${linkApiName}: ObjectTypeLinkDefinition<${definition2.targetType}Def, ${definition2.multiplicity}>`).join(",\n")}
-  },
-      properties: ${JSON.stringify(definition.properties, null, 2)},
-    }
-
-    export const ${object.objectType.apiName}: ${object.objectType.apiName}Def = {
-      type: "${definition.type}",
-      apiName: "${definition.apiName}",
-      ${definition.description != null ? `description: ${JSON.stringify(definition.description)},` : ""}
-      primaryKeyType: ${JSON.stringify(definition.primaryKeyType)},
-      links: ${JSON.stringify(definition.links, null, 2)},
-      properties: ${JSON.stringify(definition.properties, null, 2)},
-    };`;
-}
-
-// src/v1.1/generatePerObjectInterfaceAndDataFiles.ts
 async function generatePerObjectInterfaceAndDataFiles(ontology, fs, outDir, importExt = "") {
   await fs.mkdir(outDir, {
     recursive: true
@@ -1264,7 +1166,7 @@ async function generatePerObjectInterfaceAndDataFiles(ontology, fs, outDir, impo
   await Promise.all(Object.values(ontology.objectTypes).map(async (object) => {
     object.linkTypes;
     await fs.writeFile(path15__namespace.default.join(outDir, `${object.objectType.apiName}.ts`), await formatTs(`
-        import type { ObjectTypeDefinition, ObjectTypeLinkDefinition } from "@osdk/api";
+        import type { ObjectTypeDefinition, ObjectTypeLinkDefinition, PropertyDef } from "@osdk/api";
         ${wireObjectTypeV2ToObjectInterfaceStringV1(object, importExt)}
 
         ${wireObjectTypeV2ToSdkObjectConst(object, importExt)}
@@ -1539,8 +1441,9 @@ function handleQueryDataType(dataType, importedObjects, isReturnValue) {
     case "double":
     case "float":
     case "integer":
-    case "long":
       return "number";
+    case "long":
+      return isReturnValue ? "string" : "string | number";
     case "date":
       return "LocalDate";
     case "timestamp":
@@ -1662,22 +1565,38 @@ async function generateClientSdkVersionOneDotOne(ontology, userAgent, fs, outDir
   await generateIndexFile(fs, outDir, importExt);
   await generateBackCompatDeprecatedExports(fs, outDir, importExt);
 }
+function __UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(interfaceDef, v2 = false) {
+  const definition = deleteUndefineds(generatorConverters.__UNSTABLE_wireInterfaceTypeV2ToSdkObjectDefinition(interfaceDef, v2));
+  const objectDefIdentifier = getObjectDefIdentifier(interfaceDef.apiName, v2);
+  function getV2Types() {
+    return `
+  export interface ${objectDefIdentifier} extends InterfaceDefinition<"${interfaceDef.apiName}", ${interfaceDef.apiName}> {
+    ${stringify(definition, {
+      type: () => void 0,
+      apiName: () => void 0,
+      links: (_value) => `{
+      ${stringify(definition.links, {
+        "*": (definition2) => `ObjectTypeLinkDefinition<${getObjectDefIdentifier(definition2.targetType, v2)}, ${definition2.multiplicity}>`
+      })}
+    }`,
+      properties: (_value) => `{
+      ${stringify(definition.properties, {
+        "*": (propertyDefinition) => `PropertyDef<"${propertyDefinition.type}", "${propertyDefinition.nullable ? "nullable" : "non-nullable"}", "${propertyDefinition.multiplicity ? "array" : "single"}">`
+      })}
+    }`
+    })}
+  }
 
-// src/shared/UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst.ts
-function __UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(interfaceType, v2 = false) {
-  return `
-    export const ${interfaceType.apiName} = ${JSON.stringify(wireInterfaceTypeV2ToSdkObjectDefinition(interfaceType), null, 2)} satisfies InterfaceDefinition<"${interfaceType.apiName}", "">;`;
-}
-function wireInterfaceTypeV2ToSdkObjectDefinition(interfaceType, v2) {
-  return {
-    type: "interface",
-    apiName: interfaceType.apiName,
-    description: interfaceType.description,
-    properties: Object.fromEntries(Object.entries(interfaceType.properties).map(([key, value]) => {
-      return [key, wirePropertyV2ToSdkPropertyDefinition(value, true)];
-    })),
-    links: {}
-  };
+`;
+  }
+  const imports = [];
+  return `${imports.join("\n")}
+
+    ${v2 ? getV2Types() : ""}
+
+    export const ${definition.apiName}: ${objectDefIdentifier} = {
+      ${stringify(definition)}
+    };`;
 }
 async function generateOntologyMetadataFile(ontology, userAgent, fs, outDir) {
   fs.writeFile(path15__namespace.default.join(outDir, "OntologyMetadata.ts"), await formatTs(`
@@ -1693,15 +1612,19 @@ async function generateOntologyMetadataFile(ontology, userAgent, fs, outDir) {
 async function generateClientSdkVersionTwoPointZero(ontology, userAgent, fs, outDir, packageType = "commonjs") {
   await verifyOutdir(outDir, fs);
   const sanitizedOntology = sanitizeMetadata(ontology);
-  const objectNames = Object.keys(sanitizedOntology.objectTypes);
-  const actionNames = Object.keys(sanitizedOntology.actionTypes);
-  const interfaceNames = Object.keys(sanitizedOntology.interfaceTypes ?? {});
+  const objectNames = Object.keys(sanitizedOntology.objectTypes).sort((a, b) => a.localeCompare(b));
+  const actionNames = Object.keys(sanitizedOntology.actionTypes).sort((a, b) => a.localeCompare(b));
+  Object.keys(sanitizedOntology.queryTypes).sort((a, b) => a.localeCompare(b));
+  const interfaceNames = Object.keys(sanitizedOntology.interfaceTypes ?? {}).sort((a, b) => a.localeCompare(b));
   const importExt = packageType === "module" ? ".js" : "";
   await fs.mkdir(outDir, {
     recursive: true
   });
   fs.writeFile(path15__namespace.default.join(outDir, "index.ts"), await formatTs(`
         export { Ontology } from "./Ontology${importExt}";
+        export * from "./ontology/actions/index${importExt}";
+        export * from "./ontology/objects${importExt}";
+        export * from "./ontology/interfaces${importExt}";
     `));
   await generateOntologyMetadataFile(sanitizedOntology, userAgent, fs, outDir);
   await fs.writeFile(path15__namespace.default.join(outDir, "Ontology.ts"), await formatTs(`
@@ -1745,18 +1668,11 @@ async function generateClientSdkVersionTwoPointZero(ontology, userAgent, fs, out
   for (const name of objectNames) {
     const obj = ontology.objectTypes[name];
     await fs.writeFile(path15__namespace.default.join(outDir, "ontology", `objects`, `${name}.ts`), await formatTs(`
-    
-      import type { ObjectTypeDefinition, ObjectTypeLinkDefinition } from "@osdk/api";
-
-      ${wireObjectTypeV2ToSdkObjectConst(obj, importExt, true)}
+        import type { ObjectTypeDefinition, ObjectTypeLinkDefinition, PropertyDef } from "@osdk/api";
+        import { Osdk } from "@osdk/client";
 
-      ${/* TODO: FIXME
-    //   wireObjectTypeV2ToObjectDefinitionInterfaceString(
-    //     obj,
-    //   )
-    */
-    ""}
-    `));
+        ${wireObjectTypeV2ToSdkObjectConst(obj, importExt, true)}
+      `));
   }
   await generateOntologyInterfaces(fs, outDir, interfaceNames, ontology, importExt);
   const actionsDir = path15__namespace.default.join(outDir, "ontology", "actions");
@@ -1765,7 +1681,8 @@ async function generateClientSdkVersionTwoPointZero(ontology, userAgent, fs, out
   });
   await generatePerActionDataFiles(sanitizedOntology, fs, actionsDir, importExt, true);
   await fs.writeFile(path15__namespace.default.join(outDir, "ontology", "objects.ts"), await formatTs(`
-    ${Object.keys(ontology.objectTypes).map((apiName) => `export * from "./objects/${apiName}${importExt}";`).join("\n")}
+    ${Object.keys(ontology.objectTypes).sort((a, b) => a.localeCompare(b)).map((apiName) => `export * from "./objects/${apiName}${importExt}";`).join("\n")}
+    ${Object.keys(ontology.objectTypes).length === 0 ? "export {};" : ""}
     `));
 }
 function stringUnionFrom2(values) {
@@ -1784,13 +1701,14 @@ async function generateOntologyInterfaces(fs, outDir, interfaceNames, ontology,
     const obj = ontology.interfaceTypes[name];
     await fs.writeFile(path15__namespace.default.join(interfacesDir, `${name}.ts`), await formatTs(`
     
-      import type { InterfaceDefinition } from "@osdk/api";
+      import type { InterfaceDefinition, PropertyDef } from "@osdk/api";
 
       ${__UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(obj, true)}
     `));
   }
   await fs.writeFile(interfacesDir + ".ts", await formatTs(`
     ${Object.keys(ontology.interfaceTypes ?? {}).map((apiName) => `export * from "./interfaces/${apiName}${importExt}";`).join("\n")}
+    ${Object.keys(ontology.interfaceTypes ?? {}).length === 0 ? "export {}" : ""}
     `));
 }