@osdk/maker 0.13.0-beta.9 → 0.13.0

package/build/cjs/index.cjs

@@ -6,6 +6,7 @@ var consola = require('consola');
 var fs2 = require('fs/promises');
 var path2 = require('path');
 var invariant5 = require('tiny-invariant');
+var uuid = require('uuid');
 var yargs = require('yargs');
 var helpers = require('yargs/helpers');
 var fs = require('fs');
@@ -39,7 +40,23 @@ var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
 
 // src/cli/main.ts
 
-// src/api/types.ts
+// src/conversion/toMarketplace/convertActionParameters.ts
+function convertActionParameters(action) {
+  return Object.fromEntries((action.parameters ?? []).map((p) => [p.id, {
+    id: p.id,
+    type: typeof p.type === "string" ? {
+      type: p.type,
+      [p.type]: {}
+    } : p.type,
+    displayMetadata: {
+      displayName: p.displayName,
+      description: p.description ?? "",
+      typeClasses: []
+    }
+  }]));
+}
+
+// src/api/common/OntologyEntityTypeEnum.ts
 var OntologyEntityTypeEnum = /* @__PURE__ */ (function(OntologyEntityTypeEnum2) {
   OntologyEntityTypeEnum2["OBJECT_TYPE"] = "OBJECT_TYPE";
   OntologyEntityTypeEnum2["LINK_TYPE"] = "LINK_TYPE";
@@ -49,8 +66,37 @@ var OntologyEntityTypeEnum = /* @__PURE__ */ (function(OntologyEntityTypeEnum2)
   OntologyEntityTypeEnum2["VALUE_TYPE"] = "VALUE_TYPE";
   return OntologyEntityTypeEnum2;
 })({});
-var MODIFY_OBJECT_PARAMETER = "objectToModifyParameter";
-var CREATE_OR_MODIFY_OBJECT_PARAMETER = "objectToCreateOrModifyParameter";
+
+// src/api/interface/getFlattenedInterfaceProperties.ts
+function getFlattenedInterfaceProperties(interfaceType) {
+  let properties = interfaceType.propertiesV2;
+  interfaceType.extendsInterfaces.forEach((ext) => {
+    properties = {
+      ...properties,
+      ...getFlattenedInterfaceProperties(ext)
+    };
+  });
+  return properties;
+}
+
+// src/api/properties/PropertyTypeType.ts
+function isPropertyTypeType(v) {
+  return v === "boolean" || v === "byte" || v === "date" || v === "decimal" || v === "double" || v === "float" || v === "geopoint" || v === "geoshape" || v === "integer" || v === "long" || typeof v === "object" && v.type === "marking" || v === "short" || v === "string" || v === "timestamp";
+}
+function isExotic(type) {
+  if (type === void 0) {
+    return false;
+  }
+  if (typeof type === "string") {
+    return ["geopoint", "geoshape", "mediaReference", "geotimeSeries"].includes(type);
+  } else if (typeof type === "object" && type != null) {
+    return type.type === "marking" || type.type === "struct";
+  }
+  return false;
+}
+function isStruct(type) {
+  return typeof type === "object" && type.type === "struct";
+}
 
 // src/api/defineObject.ts
 var ISO_8601_DURATION = /^P(?!$)(?:(?:((?:\d+Y)|(?:\d+(?:\.|,)\d+Y$))?((?:\d+M)|(?:\d+(?:\.|,)\d+M$))?((?:\d+D)|(?:\d+(?:\.|,)\d+D$))?(T((?:\d+H)|(?:\d+(?:\.|,)\d+H$))?((?:\d+M)|(?:\d+(?:\.|,)\d+M$))?((?:\d+S)|(?:\d+(?:\.|,)\d+S$))?)?)|(?:\d+(?:(?:\.|,)\d+)?W))$/;
@@ -84,7 +130,7 @@ function defineObject(objectDef) {
   !!isExotic(objectDef.properties?.[objectDef.titlePropertyApiName]?.type) ? process.env.NODE_ENV !== "production" ? invariant5__default.default(false, `Title property ${objectDef.titlePropertyApiName} must be a primitive type`) : invariant5__default.default(false) : void 0;
   !!isExotic(objectDef.properties?.[objectDef.primaryKeyPropertyApiName]?.type) ? process.env.NODE_ENV !== "production" ? invariant5__default.default(false, `Primary key property ${objectDef.primaryKeyPropertyApiName} can only be primitive types`) : invariant5__default.default(false) : void 0;
   objectDef.implementsInterfaces?.forEach((interfaceImpl) => {
-    const allInterfaceProperties = getAllInterfaceProperties(interfaceImpl.implements);
+    const allInterfaceProperties = getFlattenedInterfaceProperties(interfaceImpl.implements);
     const nonExistentInterfaceProperties = interfaceImpl.propertyMapping.map((val) => val.interfaceProperty).filter((interfaceProperty) => allInterfaceProperties[addNamespaceIfNone(interfaceProperty)] === void 0).map((interfaceProp) => ({
       type: "invalid",
       reason: `Interface property ${interfaceProp} referenced in ${objectDef.apiName} object does not exist`
@@ -99,7 +145,7 @@ function defineObject(objectDef) {
         reason: `Interface property ${interfaceProp[1].sharedPropertyType.apiName} not implemented by ${objectDef.apiName} object definition`
       };
     };
-    const validations = Object.entries(getAllInterfaceProperties(interfaceImpl.implements)).map(validateProperty);
+    const validations = Object.entries(getFlattenedInterfaceProperties(interfaceImpl.implements)).map(validateProperty);
     const allFailedValidations = validations.concat(nonExistentInterfaceProperties).filter((val) => val.type === "invalid");
     !(allFailedValidations.length === 0) ? process.env.NODE_ENV !== "production" ? invariant5__default.default(false, "\n" + allFailedValidations.map(formatValidationErrors).join("\n")) : invariant5__default.default(false) : void 0;
   });
@@ -114,17 +160,6 @@ function defineObject(objectDef) {
   objectDef.apiName = apiName;
   return objectDef;
 }
-function isExotic(type) {
-  if (type === void 0) {
-    return false;
-  }
-  if (typeof type === "string") {
-    return ["geopoint", "geoshape", "mediaReference", "geotimeSeries"].includes(type);
-  } else if (typeof type === "object" && type != null) {
-    return type.type === "marking" || type.type === "struct";
-  }
-  return false;
-}
 function formatValidationErrors(error) {
   return `Ontology Definition Error: ${error.reason}
 `;
@@ -147,56 +182,122 @@ function validateInterfaceImplProperty(spt, mappedObjectProp, object) {
     type: "valid"
   };
 }
-function convertToDisplayName(s) {
+function uppercaseFirstLetter(s) {
   return s === void 0 || s == null ? "" : s.charAt(0).toUpperCase() + s.slice(1);
 }
 function convertToPluralDisplayName(s) {
-  return s === void 0 || s == null ? "" : s.endsWith("s") ? convertToDisplayName(s) : convertToDisplayName(s) + "s";
-}
-function getAllInterfaceProperties(interfaceType) {
-  let properties = interfaceType.propertiesV2;
-  interfaceType.extendsInterfaces.forEach((ext) => {
-    properties = {
-      ...properties,
-      ...getAllInterfaceProperties(ext)
-    };
-  });
-  return properties;
+  return s === void 0 || s == null ? "" : s.endsWith("s") ? uppercaseFirstLetter(s) : uppercaseFirstLetter(s) + "s";
 }
 function convertUserObjectPropertyType(apiName, property) {
   property.apiName = apiName;
-  property.displayName = property.displayName ?? convertToDisplayName(apiName);
+  property.displayName = property.displayName ?? uppercaseFirstLetter(apiName);
   return {
     ...property,
     apiName,
-    displayName: property.displayName ?? convertToDisplayName(apiName),
+    displayName: property.displayName ?? uppercaseFirstLetter(apiName),
     type: property.type
   };
 }
-function convertActionVisibility(visibility) {
-  switch (visibility) {
-    case "editable":
-      return {
-        type: "editable",
-        editable: {}
-      };
-    case "disabled":
+
+// src/conversion/toMarketplace/convertActionSections.ts
+function convertActionSections(action) {
+  return Object.fromEntries(Object.entries(action.sections ?? {}).map(([sectionId, section]) => [sectionId, {
+    id: sectionId,
+    content: section.parameters.map((p) => ({
+      type: "parameterId",
+      parameterId: p
+    })),
+    displayMetadata: {
+      collapsedByDefault: section.collapsedByDefault ?? false,
+      columnCount: section.columnCount ?? 1,
+      description: section.description ?? "",
+      displayName: section.displayName ?? uppercaseFirstLetter(sectionId),
+      showTitleBar: section.showTitleBar ?? true,
+      ...section.style && {
+        style: section.style === "box" ? {
+          type: "box",
+          box: {}
+        } : {
+          type: "minimal",
+          minimal: {}
+        }
+      }
+    }
+  }]));
+}
+
+// src/conversion/toMarketplace/convertConditionDefinition.ts
+function convertConditionDefinition(condition) {
+  switch (condition.type) {
+    case "and":
+      if ("conditions" in condition) {
+        return {
+          type: "and",
+          and: {
+            conditions: condition.conditions.map((c) => convertConditionDefinition(c))
+          }
+        };
+      } else {
+        return condition;
+      }
+    case "or":
+      if ("conditions" in condition) {
+        return {
+          type: "or",
+          or: {
+            conditions: condition.conditions.map((c) => convertConditionDefinition(c))
+          }
+        };
+      } else {
+        return condition;
+      }
+    case "group":
       return {
-        type: "disabled",
-        disabled: {}
+        type: "comparison",
+        comparison: {
+          operator: "INTERSECTS",
+          left: {
+            type: "userProperty",
+            userProperty: {
+              userId: {
+                type: "currentUser",
+                currentUser: {}
+              },
+              propertyValue: {
+                type: "groupIds",
+                groupIds: {}
+              }
+            }
+          },
+          right: {
+            type: "staticValue",
+            staticValue: {
+              type: "stringList",
+              stringList: {
+                strings: [condition.name]
+              }
+            }
+          }
+        }
       };
-    case "hidden":
+    case "parameter":
       return {
-        type: "hidden",
-        hidden: {}
+        type: "comparison",
+        comparison: {
+          operator: "EQUALS",
+          left: {
+            type: "parameterId",
+            parameterId: condition.parameterId
+          },
+          right: condition.matches
+        }
       };
     default:
-      return {
-        type: "editable",
-        editable: {}
-      };
+      return condition;
   }
 }
+
+// src/conversion/toMarketplace/convertActionParameterConditionalOverride.ts
 function convertActionParameterConditionalOverride(override, validation) {
   let parameterBlockOverride;
   switch (override.type) {
@@ -266,6 +367,34 @@ function convertActionParameterConditionalOverride(override, validation) {
     parameterBlockOverrides: [parameterBlockOverride]
   };
 }
+
+// src/conversion/toMarketplace/convertActionVisibility.ts
+function convertActionVisibility(visibility) {
+  switch (visibility) {
+    case "editable":
+      return {
+        type: "editable",
+        editable: {}
+      };
+    case "disabled":
+      return {
+        type: "disabled",
+        disabled: {}
+      };
+    case "hidden":
+      return {
+        type: "hidden",
+        hidden: {}
+      };
+    default:
+      return {
+        type: "editable",
+        editable: {}
+      };
+  }
+}
+
+// src/conversion/toMarketplace/convertSectionConditionalOverride.ts
 function convertSectionConditionalOverride(override, defaultVisibility) {
   return {
     condition: convertConditionDefinition(override.condition),
@@ -283,227 +412,78 @@ function convertSectionConditionalOverride(override, defaultVisibility) {
     }]
   };
 }
-function convertConditionDefinition(condition) {
-  switch (condition.type) {
-    case "and":
-      if ("conditions" in condition) {
-        return {
-          type: "and",
-          and: {
-            conditions: condition.conditions.map((c) => convertConditionDefinition(c))
+
+// src/conversion/toMarketplace/convertActionValidation.ts
+function convertActionValidation(action) {
+  return {
+    actionTypeLevelValidation: {
+      rules: Object.fromEntries((action.validation ?? [{
+        condition: {
+          type: "true",
+          true: {}
+        },
+        displayMetadata: {
+          failureMessage: "",
+          typeClasses: []
+        }
+      }]).map((rule, idx) => [idx, rule]))
+    },
+    parameterValidations: Object.fromEntries((action.parameters ?? []).map((p) => {
+      return [p.id, {
+        defaultValidation: {
+          display: {
+            renderHint: renderHintFromBaseType(p),
+            visibility: convertActionVisibility(p.validation.defaultVisibility),
+            ...p.defaultValue && {
+              prefill: p.defaultValue
+            }
+          },
+          validation: {
+            allowedValues: extractAllowedValues(p.validation.allowedValues),
+            required: convertParameterRequirementConstraint(p.validation.required)
           }
-        };
-      } else {
-        return condition;
-      }
-    case "or":
-      if ("conditions" in condition) {
-        return {
-          type: "or",
-          or: {
-            conditions: condition.conditions.map((c) => convertConditionDefinition(c))
+        },
+        conditionalOverrides: p.validation.conditionalOverrides?.map((override) => convertActionParameterConditionalOverride(override, p.validation)) ?? []
+      }];
+    })),
+    sectionValidations: {
+      ...Object.fromEntries(Object.entries(action.sections ?? {}).map(([sectionId, section]) => [section.id, {
+        defaultDisplayMetadata: section.defaultVisibility === "hidden" ? {
+          visibility: {
+            type: "hidden",
+            hidden: {}
           }
-        };
-      } else {
-        return condition;
-      }
-    case "group":
-      return {
-        type: "comparison",
-        comparison: {
-          operator: "INTERSECTS",
-          left: {
-            type: "userProperty",
-            userProperty: {
-              userId: {
-                type: "currentUser",
-                currentUser: {}
-              },
-              propertyValue: {
-                type: "groupIds",
-                groupIds: {}
-              }
-            }
-          },
-          right: {
-            type: "staticValue",
-            staticValue: {
-              type: "stringList",
-              stringList: {
-                strings: [condition.name]
-              }
-            }
+        } : {
+          visibility: {
+            type: "visible",
+            visible: {}
           }
-        }
-      };
-    case "parameter":
-      return {
-        type: "comparison",
-        comparison: {
-          operator: "EQUALS",
-          left: {
-            type: "parameterId",
-            parameterId: condition.parameterId
-          },
-          right: condition.matches
-        }
-      };
-    default:
-      return condition;
-  }
-}
-function getFormContentOrdering(action, parameterOrdering) {
-  if (!action.sections) return [];
-  const parametersToSection = Object.fromEntries(Object.entries(action.sections).flatMap(([sectionId, section]) => section.parameters.map((param) => [param, sectionId])));
-  const seenIds = /* @__PURE__ */ new Set();
-  const formContentOrdering = [];
-  parameterOrdering.forEach((param) => {
-    if (param in parametersToSection && !seenIds.has(parametersToSection[param])) {
-      formContentOrdering.push({
-        type: "sectionId",
-        sectionId: parametersToSection[param]
-      });
-      seenIds.add(parametersToSection[param]);
-    } else if (!(param in parametersToSection)) {
-      formContentOrdering.push({
-        type: "parameterId",
-        parameterId: param
-      });
-      seenIds.add(param);
+        },
+        conditionalOverrides: section.conditionalOverrides?.map((override) => convertSectionConditionalOverride(override, section.defaultVisibility ?? "visible")) ?? []
+      }]))
     }
-  });
-  return formContentOrdering;
-}
-function convertMappingValue(value) {
-  switch (value.type) {
-    case "uuid":
-      return {
-        type: "uniqueIdentifier",
-        uniqueIdentifier: {
-          linkId: value.linkId ?? crypto.randomUUID()
-        }
-      };
-    case "currentTime":
-      return {
-        type: "currentTime",
-        currentTime: {}
-      };
-    case "currentUser":
-      return {
-        type: "currentUser",
-        currentUser: {}
-      };
-    default:
-      return value;
-  }
-}
-var defaultTypeClasses = [{
-  kind: "render_hint",
-  name: "SELECTABLE"
-}, {
-  kind: "render_hint",
-  name: "SORTABLE"
-}];
-function shouldNotHaveRenderHints(type) {
-  return ["struct", "mediaReference", "geotimeSeries"].includes(getPropertyTypeName(type));
-}
-function hasRenderHints(typeClasses) {
-  return (typeClasses ?? []).some((tc) => tc.kind.toLowerCase() === "render_hint");
-}
-function getPropertyTypeName(type) {
-  return typeof type === "object" ? type.type : type;
-}
-function convertValueType(valueType) {
-  return {
-    apiName: valueType.apiName,
-    version: valueType.version,
-    packageNamespace: valueType.packageNamespace,
-    displayMetadata: valueType.displayMetadata
-  };
-}
-function convertValueTypeDataConstraints(dataConstraints) {
-  if (dataConstraints.length === 0) {
-    return void 0;
-  }
-  const propertyTypeConstraints = dataConstraints.map((constraint) => ({
-    constraints: dataConstraintToPropertyTypeDataConstraint(constraint.constraint.constraint),
-    failureMessage: constraint.constraint.failureMessage
-  }));
-  return {
-    propertyTypeConstraints
   };
 }
-function dataConstraintToPropertyTypeDataConstraint(dc) {
-  switch (dc.type) {
-    case "array":
-      return {
-        ...dc
-      };
-    case "boolean":
-      return {
-        ...dc
-      };
-    case "binary":
-      throw new Error("Binary type constraints are not supported");
-    case "date":
-      return {
-        ...dc
-      };
-    case "decimal":
-      return {
-        ...dc
-      };
-    case "double":
-      return {
-        ...dc
-      };
-    case "float":
-      return {
-        ...dc
-      };
-    case "integer":
-      return {
-        ...dc
-      };
-    case "long":
-      return {
-        ...dc
-      };
-    case "map":
-      throw new Error("Map type constraints are not supported");
-    case "nullable":
-      throw new Error("Nullable constraints are not supported");
-    case "short":
-      return {
-        ...dc
-      };
-    case "string":
-      return {
-        ...dc
-      };
-    case "struct":
-      return {
-        type: "struct",
-        struct: {
-          elementConstraints: Object.fromEntries(Object.entries(dc.struct.elementConstraints).map(([field, constraint]) => [field, convertDataConstraintToDataConstraints(constraint)]))
-        }
-      };
-    case "structV2":
-      throw new Error("StructV2 constraints are not supported");
-    case "timestamp":
-      return {
-        ...dc
-      };
-    default:
-      throw new Error(`Unknown DataConstraint type: ${dc.type}`);
+function convertParameterRequirementConstraint(required) {
+  if (typeof required === "boolean") {
+    return required ? {
+      type: "required",
+      required: {}
+    } : {
+      type: "notRequired",
+      notRequired: {}
+    };
   }
-}
-function convertDataConstraintToDataConstraints(dc) {
+  const {
+    min,
+    max
+  } = required.listLength;
   return {
-    propertyTypeConstraints: [{
-      constraints: dataConstraintToPropertyTypeDataConstraint(dc)
-      // known limitation: structs don't carry field-level data constraint failure messages
-    }]
+    type: "listLengthValidation",
+    listLengthValidation: {
+      minLength: min,
+      maxLength: max
+    }
   };
 }
 function convertNullabilityToDataConstraint(prop) {
@@ -531,7 +511,17 @@ function convertNullabilityToDataConstraint(prop) {
     nullabilityV2: prop.nullability
   };
 }
-function convertType(type) {
+
+// src/conversion/toConjure/distributeTypeHelper.ts
+function distributeTypeHelper(type) {
+  return {
+    type,
+    [type]: {}
+  };
+}
+
+// src/conversion/toMarketplace/propertyTypeTypeToOntologyIrType.ts
+function propertyTypeTypeToOntologyIrType(type) {
   switch (true) {
     case (typeof type === "object" && "markingType" in type):
       return {
@@ -554,14 +544,14 @@ function convertType(type) {
             },
             typeClasses: [],
             aliases: [],
-            fieldType: convertType(fieldTypeDefinition)
+            fieldType: propertyTypeTypeToOntologyIrType(fieldTypeDefinition)
           };
         } else {
           if ("fieldType" in fieldTypeDefinition) {
             field = {
               ...fieldTypeDefinition,
               apiName: key,
-              fieldType: convertType(fieldTypeDefinition.fieldType),
+              fieldType: propertyTypeTypeToOntologyIrType(fieldTypeDefinition.fieldType),
               typeClasses: fieldTypeDefinition.typeClasses ?? [],
               aliases: fieldTypeDefinition.aliases ?? []
             };
@@ -574,7 +564,7 @@ function convertType(type) {
               },
               typeClasses: [],
               aliases: [],
-              fieldType: convertType(fieldTypeDefinition)
+              fieldType: propertyTypeTypeToOntologyIrType(fieldTypeDefinition)
             };
           }
         }
@@ -635,284 +625,207 @@ function convertType(type) {
       return distributeTypeHelper(type);
   }
 }
-function distributeTypeHelper(type) {
-  return {
-    type,
-    [type]: {}
-  };
-}
 
-// src/api/defineOntology.ts
-var ontologyDefinition;
-var importedTypes;
-var dependencies;
-var namespace;
-function updateOntology(entity) {
-  if (entity.__type !== OntologyEntityTypeEnum.VALUE_TYPE) {
-    ontologyDefinition[entity.__type][entity.apiName] = entity;
-    return;
-  }
-  if (ontologyDefinition[OntologyEntityTypeEnum.VALUE_TYPE][entity.apiName] === void 0) {
-    ontologyDefinition[OntologyEntityTypeEnum.VALUE_TYPE][entity.apiName] = [];
-  }
-  ontologyDefinition[OntologyEntityTypeEnum.VALUE_TYPE][entity.apiName].push(entity);
-}
-async function defineOntology(ns, body, outputDir, dependencyFile) {
-  namespace = ns;
-  dependencies = {};
-  ontologyDefinition = {
-    OBJECT_TYPE: {},
-    ACTION_TYPE: {},
-    LINK_TYPE: {},
-    INTERFACE_TYPE: {},
-    SHARED_PROPERTY_TYPE: {},
-    VALUE_TYPE: {}
-  };
-  importedTypes = {
-    SHARED_PROPERTY_TYPE: {},
-    OBJECT_TYPE: {},
-    ACTION_TYPE: {},
-    LINK_TYPE: {},
-    INTERFACE_TYPE: {},
-    VALUE_TYPE: {}
-  };
-  try {
-    await body();
-  } catch (e) {
-    console.error("Unexpected error while processing the body of the ontology", e);
-    throw e;
-  }
-  if (outputDir) {
-    writeStaticObjects(outputDir);
-  }
-  if (dependencyFile) {
-    writeDependencyFile(dependencyFile);
-  }
-  return convertToWireOntologyIr(ontologyDefinition);
-}
-function writeStaticObjects(outputDir) {
-  const codegenDir = path2__namespace.resolve(outputDir, "codegen");
-  const typeDirs = {
-    [OntologyEntityTypeEnum.SHARED_PROPERTY_TYPE]: "shared-property-types",
-    [OntologyEntityTypeEnum.ACTION_TYPE]: "action-types",
-    [OntologyEntityTypeEnum.OBJECT_TYPE]: "object-types",
-    [OntologyEntityTypeEnum.LINK_TYPE]: "link-types",
-    [OntologyEntityTypeEnum.INTERFACE_TYPE]: "interface-types",
-    [OntologyEntityTypeEnum.VALUE_TYPE]: "value-types"
-  };
-  if (!fs__namespace.existsSync(codegenDir)) {
-    fs__namespace.mkdirSync(codegenDir, {
-      recursive: true
-    });
-  }
-  Object.values(typeDirs).forEach((typeDirNameFromMap) => {
-    const currentTypeDirPath = path2__namespace.join(codegenDir, typeDirNameFromMap);
-    if (fs__namespace.existsSync(currentTypeDirPath)) {
-      fs__namespace.rmSync(currentTypeDirPath, {
-        recursive: true,
-        force: true
-      });
-    }
-    fs__namespace.mkdirSync(currentTypeDirPath, {
-      recursive: true
-    });
-  });
-  const topLevelExportStatements = [];
-  Object.entries(ontologyDefinition).forEach(([ontologyTypeEnumKey, entities]) => {
-    const typeDirName = typeDirs[ontologyTypeEnumKey];
-    const typeDirPath = path2__namespace.join(codegenDir, typeDirName);
-    const entityModuleNames = [];
-    Object.entries(entities).forEach(([apiName, entity]) => {
-      const entityFileNameBase = camel(withoutNamespace(apiName)) + (ontologyTypeEnumKey === OntologyEntityTypeEnum.VALUE_TYPE ? "ValueType" : "");
-      const filePath = path2__namespace.join(typeDirPath, `${entityFileNameBase}.ts`);
-      const entityTypeName = getEntityTypeName(ontologyTypeEnumKey);
-      const entityJSON = JSON.stringify(entity, null, 2).replace(/("__type"\s*:\s*)"([^"]*)"/g, (_, prefix, value) => `${prefix}OntologyEntityTypeEnum.${value}`);
-      const content = `
-import { wrapWithProxy, OntologyEntityTypeEnum } from '@osdk/maker';
-import type { ${entityTypeName} } from '@osdk/maker';
-
-const ${entityFileNameBase}_base: ${entityTypeName} = ${ontologyTypeEnumKey === "VALUE_TYPE" ? entityJSON.slice(1, -2) : entityJSON} as unknown as ${entityTypeName};
-        
-export const ${entityFileNameBase}: ${entityTypeName} = wrapWithProxy(${entityFileNameBase}_base);
-        `;
-      fs__namespace.writeFileSync(filePath, content, {
-        flag: "w"
-      });
-      entityModuleNames.push(entityFileNameBase);
-    });
-    for (const entityModuleName of entityModuleNames) {
-      topLevelExportStatements.push(`export { ${entityModuleName} } from "./codegen/${typeDirName}/${entityModuleName}.js";`);
-    }
+// src/conversion/toMarketplace/convertSpt.ts
+function convertSpt({
+  type,
+  array,
+  description,
+  apiName,
+  displayName,
+  visibility,
+  gothamMapping,
+  typeClasses,
+  valueType,
+  nullability
+}) {
+  const dataConstraint = convertNullabilityToDataConstraint({
+    type,
+    nullability
   });
-  if (topLevelExportStatements.length > 0) {
-    const mainIndexContent = dependencyInjectionString() + topLevelExportStatements.join("\n") + "\n";
-    const mainIndexFilePath = path2__namespace.join(outputDir, "index.ts");
-    fs__namespace.writeFileSync(mainIndexFilePath, mainIndexContent, {
-      flag: "w"
-    });
-  }
-}
-function convertOntologyToValueTypeIr(ontology) {
   return {
-    valueTypes: convertValueTypesToIr(ontology[OntologyEntityTypeEnum.VALUE_TYPE])
-  };
-}
-function convertValueTypesToIr(valueTypes) {
-  return Object.values(valueTypes).map((definitions) => ({
-    metadata: {
-      apiName: definitions[0].apiName,
-      packageNamespace: definitions[0].packageNamespace,
-      displayMetadata: definitions[0].displayMetadata,
-      status: definitions[0].status
+    apiName,
+    displayMetadata: {
+      displayName: displayName ?? apiName,
+      visibility: visibility ?? "NORMAL",
+      description
     },
-    // TODO(dpaquin): instead of deduping here, we should refactor the value type types from arrays to maps
-    versions: Array.from(new Map(definitions.map((definition) => [definition.version, definition])).values()).map((definition) => ({
-      version: definition.version,
-      baseType: definition.baseType,
-      constraints: definition.constraints,
-      exampleValues: definition.exampleValues
-    }))
-  }));
-}
-function convertToWireOntologyIr(ontology) {
-  return {
-    ontology: convertToWireBlockData(ontology),
-    importedOntology: convertToWireBlockData(importedTypes),
-    valueTypes: convertOntologyToValueTypeIr(ontology),
-    importedValueTypes: convertOntologyToValueTypeIr(importedTypes)
-  };
-}
-function convertToWireBlockData(ontology) {
-  return {
-    objectTypes: Object.fromEntries(Object.entries(ontology[OntologyEntityTypeEnum.OBJECT_TYPE]).map(([apiName, objectType]) => {
-      return [apiName, convertObject(objectType)];
-    })),
-    sharedPropertyTypes: Object.fromEntries(Object.entries(ontology[OntologyEntityTypeEnum.SHARED_PROPERTY_TYPE]).map(([apiName, spt]) => [apiName, {
-      sharedPropertyType: convertSpt(spt)
-    }])),
-    interfaceTypes: Object.fromEntries(Object.entries(ontology[OntologyEntityTypeEnum.INTERFACE_TYPE]).map(([apiName, interfaceType]) => {
-      return [apiName, {
-        interfaceType: convertInterface(interfaceType)
-      }];
-    })),
-    linkTypes: Object.fromEntries(Object.entries(ontology[OntologyEntityTypeEnum.LINK_TYPE]).map(([id, link]) => {
-      return [id, convertLink(link)];
-    })),
-    actionTypes: Object.fromEntries(Object.entries(ontology[OntologyEntityTypeEnum.ACTION_TYPE]).map(([apiName, action]) => {
-      return [apiName, convertAction(action)];
-    })),
-    blockPermissionInformation: {
-      actionTypes: Object.fromEntries(Object.entries(ontology[OntologyEntityTypeEnum.ACTION_TYPE]).filter(([apiName, action]) => action.validation).map(([apiName, action]) => {
-        return [apiName, {
-          restrictionStatus: {
-            hasRolesApplied: true,
-            ontologyPackageRid: null,
-            publicProject: false
-          }
-        }];
-      })),
-      linkTypes: {},
-      objectTypes: {}
+    type: array ? {
+      type: "array",
+      array: {
+        subtype: propertyTypeTypeToOntologyIrType(type)
+      }
+    } : propertyTypeTypeToOntologyIrType(type),
+    aliases: [],
+    baseFormatter: void 0,
+    dataConstraints: dataConstraint,
+    gothamMapping,
+    indexedForSearch: true,
+    typeClasses: typeClasses ?? [],
+    valueType: valueType === void 0 ? void 0 : {
+      apiName: valueType.apiName,
+      version: valueType.version,
+      packageNamespace: valueType.packageNamespace,
+      displayMetadata: valueType.displayMetadata
     }
   };
 }
-function convertObject(objectType) {
-  const propertyDatasources = (objectType.properties ?? []).flatMap((prop) => extractPropertyDatasource(prop, objectType.apiName));
-  const classificationGroupMarkingNames = extractMarkingGroups(objectType.properties ?? [], "CBAC");
-  const mandatoryMarkingNames = extractMarkingGroups(objectType.properties ?? [], "MANDATORY");
-  const classificationInputGroup = classificationGroupMarkingNames.length > 0 ? classificationGroupMarkingNames.reduce((l, r) => l + "/" + r) : void 0;
-  const mandatoryInputGroup = mandatoryMarkingNames.length > 0 ? mandatoryMarkingNames.reduce((l, r) => l + "/" + r) : void 0;
-  const objectDatasource = buildDatasource(objectType.apiName, convertDatasourceDefinition(objectType, objectType.properties ?? []), classificationInputGroup, mandatoryInputGroup);
-  const implementations = objectType.implementsInterfaces ?? [];
+
+// src/conversion/toMarketplace/convertInterface.ts
+function convertInterface(interfaceType) {
+  const {
+    __type,
+    ...other
+  } = interfaceType;
   return {
-    objectType: {
-      displayMetadata: {
-        description: objectType.description,
-        displayName: objectType.displayName,
-        groupDisplayName: void 0,
-        icon: {
-          type: "blueprint",
-          blueprint: objectType.icon ?? {
-            locator: "cube",
-            color: "#2D72D2"
-          }
-        },
-        pluralDisplayName: objectType.pluralDisplayName,
-        visibility: objectType.visibility ?? "NORMAL"
-      },
-      primaryKeys: [objectType.primaryKeyPropertyApiName],
-      propertyTypes: Object.fromEntries(objectType.properties?.map((val) => [val.apiName, convertProperty(val)]) ?? []),
-      titlePropertyTypeRid: objectType.titlePropertyApiName,
-      apiName: objectType.apiName,
-      status: convertObjectStatus(objectType.status),
-      redacted: false,
-      implementsInterfaces2: implementations.map((impl) => ({
-        interfaceTypeApiName: impl.implements.apiName,
-        linksV2: {},
-        propertiesV2: {},
-        properties: Object.fromEntries(impl.propertyMapping.map((mapping) => [addNamespaceIfNone(mapping.interfaceProperty), {
-          propertyTypeRid: mapping.mapsTo
-        }]))
-      })),
-      allImplementsInterfaces: {}
+    ...other,
+    propertiesV2: Object.fromEntries(Object.values(interfaceType.propertiesV2).map((spt) => [spt.sharedPropertyType.apiName, {
+      required: spt.required,
+      sharedPropertyType: convertSpt(spt.sharedPropertyType)
+    }])),
+    displayMetadata: {
+      displayName: interfaceType.displayMetadata.displayName,
+      description: interfaceType.displayMetadata.description,
+      icon: interfaceType.displayMetadata.icon ?? {
+        type: "blueprint",
+        blueprint: {
+          color: "#4C90F0",
+          locator: "layout-hierarchy"
+        }
+      }
     },
-    datasources: [...propertyDatasources, objectDatasource],
-    entityMetadata: {
-      arePatchesEnabled: objectType.editsEnabled ?? false
-    }
+    extendsInterfaces: interfaceType.extendsInterfaces.map((i) => i.apiName),
+    // these are omitted from our internal types but we need to re-add them for the final json
+    properties: [],
+    // TODO(mwalther): Support propertiesV3
+    propertiesV3: {}
   };
 }
-function extractPropertyDatasource(property, objectTypeApiName) {
-  if (!isExotic(property.type)) {
-    return [];
+
+// src/conversion/toMarketplace/convertCardinality.ts
+function convertCardinality(cardinality) {
+  if (cardinality === "OneToMany" || cardinality === void 0) {
+    return "ONE_TO_MANY";
   }
-  const identifier = objectTypeApiName + "." + property.apiName;
-  switch (property.type) {
-    case "geotimeSeries":
-      const geotimeDefinition = {
-        type: "geotimeSeries",
-        geotimeSeries: {
-          geotimeSeriesIntegrationRid: identifier,
-          properties: [property.apiName]
-        }
-      };
-      return [buildDatasource(property.apiName, geotimeDefinition)];
-    case "mediaReference":
-      const mediaSetDefinition = {
-        type: "mediaSetView",
-        mediaSetView: {
-          assumedMarkings: [],
-          mediaSetViewLocator: identifier,
-          properties: [property.apiName]
+  return "ONE_TO_ONE";
+}
+
+// src/conversion/toMarketplace/convertLink.ts
+function convertLink(linkType) {
+  let definition;
+  let datasource = void 0;
+  if ("one" in linkType) {
+    definition = {
+      type: "oneToMany",
+      oneToMany: {
+        cardinalityHint: convertCardinality(linkType.cardinality),
+        manyToOneLinkMetadata: linkType.toMany.metadata,
+        objectTypeRidManySide: linkType.toMany.object.apiName,
+        objectTypeRidOneSide: linkType.one.object.apiName,
+        oneToManyLinkMetadata: linkType.one.metadata,
+        oneSidePrimaryKeyToManySidePropertyMapping: [{
+          from: {
+            apiName: linkType.one.object.primaryKeyPropertyApiName,
+            object: linkType.one.object.apiName
+          },
+          to: {
+            apiName: linkType.manyForeignKeyProperty,
+            object: linkType.toMany.object.apiName
+          }
+        }]
+      }
+    };
+  } else if ("intermediaryObjectType" in linkType) {
+    definition = {
+      type: "intermediary",
+      intermediary: {
+        objectTypeAToBLinkMetadata: linkType.many.metadata,
+        objectTypeBToALinkMetadata: linkType.toMany.metadata,
+        objectTypeRidA: linkType.many.object.apiName,
+        objectTypeRidB: linkType.toMany.object.apiName,
+        intermediaryObjectTypeRid: linkType.intermediaryObjectType.apiName,
+        aToIntermediaryLinkTypeRid: cleanAndValidateLinkTypeId(linkType.many.linkToIntermediary.apiName),
+        intermediaryToBLinkTypeRid: cleanAndValidateLinkTypeId(linkType.toMany.linkToIntermediary.apiName)
+      }
+    };
+  } else {
+    definition = {
+      type: "manyToMany",
+      manyToMany: {
+        objectTypeAToBLinkMetadata: linkType.many.metadata,
+        objectTypeBToALinkMetadata: linkType.toMany.metadata,
+        objectTypeRidA: linkType.many.object.apiName,
+        objectTypeRidB: linkType.toMany.object.apiName,
+        peeringMetadata: void 0,
+        objectTypeAPrimaryKeyPropertyMapping: [{
+          from: {
+            apiName: linkType.many.object.primaryKeyPropertyApiName,
+            object: linkType.many.object.apiName
+          },
+          to: {
+            apiName: linkType.many.object.primaryKeyPropertyApiName,
+            object: linkType.many.object.apiName
+          }
+        }],
+        objectTypeBPrimaryKeyPropertyMapping: [{
+          from: {
+            apiName: linkType.toMany.object.primaryKeyPropertyApiName,
+            object: linkType.toMany.object.apiName
+          },
+          to: {
+            apiName: linkType.toMany.object.primaryKeyPropertyApiName,
+            object: linkType.toMany.object.apiName
+          }
+        }]
+      }
+    };
+    datasource = {
+      datasourceName: linkType.apiName,
+      datasource: {
+        type: "dataset",
+        dataset: {
+          datasetRid: "link-".concat(linkType.apiName),
+          writebackDatasetRid: void 0,
+          objectTypeAPrimaryKeyMapping: [{
+            property: {
+              apiName: linkType.many.object.primaryKeyPropertyApiName,
+              object: linkType.many.object.apiName
+            },
+            column: linkType.many.object.primaryKeyPropertyApiName
+          }],
+          objectTypeBPrimaryKeyMapping: [{
+            property: {
+              apiName: linkType.toMany.object.primaryKeyPropertyApiName,
+              object: linkType.toMany.object.apiName
+            },
+            column: linkType.toMany.object.primaryKeyPropertyApiName
+          }]
         }
-      };
-      return [buildDatasource(property.apiName, mediaSetDefinition)];
-    default:
-      return [];
+      },
+      editsConfiguration: {
+        onlyAllowPrivilegedEdits: false
+      },
+      redacted: linkType.redacted
+    };
   }
-}
-function buildDatasource(apiName, definition, classificationMarkingGroupName, mandatoryMarkingGroupName) {
-  const needsSecurity = classificationMarkingGroupName !== void 0 || mandatoryMarkingGroupName !== void 0;
-  const securityConfig = needsSecurity ? {
-    classificationConstraint: classificationMarkingGroupName ? {
-      markingGroupName: classificationMarkingGroupName
-    } : void 0,
-    markingConstraint: mandatoryMarkingGroupName ? {
-      markingGroupName: mandatoryMarkingGroupName
-    } : void 0
-  } : void 0;
   return {
-    rid: "ri.ontology.main.datasource.".concat(apiName),
-    datasource: definition,
-    editsConfiguration: {
-      onlyAllowPrivilegedEdits: false
+    linkType: {
+      definition,
+      id: cleanAndValidateLinkTypeId(linkType.apiName),
+      status: linkType.status ?? {
+        type: "active",
+        active: {}
+      },
+      redacted: linkType.redacted ?? false
     },
-    redacted: false,
-    ...securityConfig !== void 0 && {
-      dataSecurity: securityConfig
+    datasources: datasource !== void 0 ? [datasource] : [],
+    entityMetadata: {
+      arePatchesEnabled: linkType.editsEnabled ?? false
     }
   };
 }
+
+// src/conversion/toMarketplace/convertDatasourceDefinition.ts
 function convertDatasourceDefinition(objectType, properties) {
   switch (objectType.datasource?.type) {
     case "stream":
@@ -955,14 +868,6 @@ function convertDatasourceDefinition(objectType, properties) {
       };
   }
 }
-function extractMarkingGroups(properties, markingType) {
-  return properties.map((prop) => {
-    if (typeof prop.type === "object" && prop.type.type === "marking" && prop.type.markingType === markingType) {
-      return prop.type.markingInputGroupName;
-    }
-    return void 0;
-  }).filter((val) => val !== void 0);
-}
 function buildPropertyMapping(properties) {
   return Object.fromEntries(properties.map((prop) => {
     if (prop.editOnly) {
@@ -990,7 +895,128 @@ function buildPropertyMapping(properties) {
     }];
   }));
 }
-function convertProperty(property) {
+
+// src/api/propertyConversionUtils.ts
+var defaultTypeClasses = [{
+  kind: "render_hint",
+  name: "SELECTABLE"
+}, {
+  kind: "render_hint",
+  name: "SORTABLE"
+}];
+function shouldNotHaveRenderHints(type) {
+  return ["struct", "mediaReference", "geotimeSeries"].includes(getPropertyTypeName(type));
+}
+function hasRenderHints(typeClasses) {
+  return (typeClasses ?? []).some((tc) => tc.kind.toLowerCase() === "render_hint");
+}
+function getPropertyTypeName(type) {
+  return typeof type === "object" ? type.type : type;
+}
+
+// src/conversion/toMarketplace/convertValueType.ts
+function convertValueType(valueType) {
+  return {
+    apiName: valueType.apiName,
+    version: valueType.version,
+    packageNamespace: valueType.packageNamespace,
+    displayMetadata: valueType.displayMetadata
+  };
+}
+
+// src/conversion/toMarketplace/convertDataConstraintToDataConstraints.ts
+function convertDataConstraintToDataConstraints(dc) {
+  return {
+    propertyTypeConstraints: [{
+      constraints: dataConstraintToPropertyTypeDataConstraint(dc)
+      // known limitation: structs don't carry field-level data constraint failure messages
+    }]
+  };
+}
+
+// src/conversion/toMarketplace/dataConstraintToPropertyTypeDataConstraint.ts
+function dataConstraintToPropertyTypeDataConstraint(dc) {
+  switch (dc.type) {
+    case "array":
+      return {
+        ...dc
+      };
+    case "boolean":
+      return {
+        ...dc
+      };
+    case "binary":
+      throw new Error("Binary type constraints are not supported");
+    case "date":
+      return {
+        ...dc
+      };
+    case "decimal":
+      return {
+        ...dc
+      };
+    case "double":
+      return {
+        ...dc
+      };
+    case "float":
+      return {
+        ...dc
+      };
+    case "integer":
+      return {
+        ...dc
+      };
+    case "long":
+      return {
+        ...dc
+      };
+    case "map":
+      throw new Error("Map type constraints are not supported");
+    case "nullable":
+      throw new Error("Nullable constraints are not supported");
+    case "short":
+      return {
+        ...dc
+      };
+    case "string":
+      return {
+        ...dc
+      };
+    case "struct":
+      return {
+        type: "struct",
+        struct: {
+          elementConstraints: Object.fromEntries(Object.entries(dc.struct.elementConstraints).map(([field, constraint]) => [field, convertDataConstraintToDataConstraints(constraint)]))
+        }
+      };
+    case "structV2":
+      throw new Error("StructV2 constraints are not supported");
+    case "timestamp":
+      return {
+        ...dc
+      };
+    default:
+      throw new Error(`Unknown DataConstraint type: ${dc.type}`);
+  }
+}
+
+// src/conversion/toMarketplace/convertValueTypeDataConstraints.ts
+function convertValueTypeDataConstraints(dataConstraints) {
+  if (dataConstraints.length === 0) {
+    return void 0;
+  }
+  const propertyTypeConstraints = dataConstraints.map((constraint) => ({
+    constraints: dataConstraintToPropertyTypeDataConstraint(constraint.constraint.constraint),
+    failureMessage: constraint.constraint.failureMessage
+  }));
+  return {
+    propertyTypeConstraints
+  };
+}
+
+// src/conversion/toMarketplace/convertObjectPropertyType.ts
+function convertObjectPropertyType(property) {
   const apiName = namespace + property.apiName;
   !(!shouldNotHaveRenderHints(property.type) || !hasRenderHints(property.typeClasses)) ? process.env.NODE_ENV !== "production" ? invariant5__default.default(false, `Property type ${apiName} of type '${getPropertyTypeName(property.type)}' should not have render hints`) : invariant5__default.default(false) : void 0;
   const output = {
@@ -1007,9 +1033,9 @@ function convertProperty(property) {
     type: property.array ? {
       type: "array",
       array: {
-        subtype: convertType(property.type)
+        subtype: propertyTypeTypeToOntologyIrType(property.type)
       }
-    } : convertType(property.type),
+    } : propertyTypeTypeToOntologyIrType(property.type),
     typeClasses: property.typeClasses ?? (shouldNotHaveRenderHints(property.type) ? [] : defaultTypeClasses),
     status: convertObjectStatus(property.status),
     inlineAction: void 0,
@@ -1019,103 +1045,318 @@ function convertProperty(property) {
   };
   return output;
 }
-function convertLink(linkType) {
-  let definition;
-  let datasource = void 0;
-  if ("one" in linkType) {
-    definition = {
-      type: "oneToMany",
-      oneToMany: {
-        cardinalityHint: convertCardinality(linkType.cardinality),
-        manyToOneLinkMetadata: linkType.toMany.metadata,
-        objectTypeRidManySide: linkType.toMany.object.apiName,
-        objectTypeRidOneSide: linkType.one.object.apiName,
-        oneToManyLinkMetadata: linkType.one.metadata,
-        oneSidePrimaryKeyToManySidePropertyMapping: [{
-          from: {
-            apiName: linkType.one.object.primaryKeyPropertyApiName,
-            object: linkType.one.object.apiName
-          },
-          to: {
-            apiName: linkType.manyForeignKeyProperty,
-            object: linkType.toMany.object.apiName
-          }
-        }]
-      }
-    };
-  } else {
-    definition = {
-      type: "manyToMany",
-      manyToMany: {
-        objectTypeAToBLinkMetadata: linkType.many.metadata,
-        objectTypeBToALinkMetadata: linkType.toMany.metadata,
-        objectTypeRidA: linkType.many.object.apiName,
-        objectTypeRidB: linkType.toMany.object.apiName,
-        peeringMetadata: void 0,
-        objectTypeAPrimaryKeyPropertyMapping: [{
-          from: {
-            apiName: linkType.many.object.primaryKeyPropertyApiName,
-            object: linkType.many.object.apiName
-          },
-          to: {
-            apiName: linkType.many.object.primaryKeyPropertyApiName,
-            object: linkType.many.object.apiName
-          }
-        }],
-        objectTypeBPrimaryKeyPropertyMapping: [{
-          from: {
-            apiName: linkType.toMany.object.primaryKeyPropertyApiName,
-            object: linkType.toMany.object.apiName
-          },
-          to: {
-            apiName: linkType.toMany.object.primaryKeyPropertyApiName,
-            object: linkType.toMany.object.apiName
+
+// src/conversion/toMarketplace/convertObject.ts
+function convertObject(objectType) {
+  const propertyDatasources = (objectType.properties ?? []).flatMap((prop) => extractPropertyDatasource(prop, objectType.apiName));
+  const classificationGroupMarkingNames = extractMarkingGroups(objectType.properties ?? [], "CBAC");
+  const mandatoryMarkingNames = extractMarkingGroups(objectType.properties ?? [], "MANDATORY");
+  const classificationInputGroup = classificationGroupMarkingNames.length > 0 ? classificationGroupMarkingNames.reduce((l, r) => l + "/" + r) : void 0;
+  const mandatoryInputGroup = mandatoryMarkingNames.length > 0 ? mandatoryMarkingNames.reduce((l, r) => l + "/" + r) : void 0;
+  const objectDatasource = buildDatasource(objectType.apiName, convertDatasourceDefinition(objectType, objectType.properties ?? []), classificationInputGroup, mandatoryInputGroup);
+  const implementations = objectType.implementsInterfaces ?? [];
+  return {
+    objectType: {
+      displayMetadata: {
+        description: objectType.description,
+        displayName: objectType.displayName,
+        groupDisplayName: void 0,
+        icon: {
+          type: "blueprint",
+          blueprint: objectType.icon ?? {
+            locator: "cube",
+            color: "#2D72D2"
           }
-        }]
-      }
-    };
-    datasource = {
-      rid: "ri.ontology.main.datasource.link-".concat(linkType.apiName),
-      datasource: {
-        type: "dataset",
-        dataset: {
-          datasetRid: "link-".concat(linkType.apiName),
-          writebackDatasetRid: void 0,
-          objectTypeAPrimaryKeyMapping: [{
-            property: {
-              apiName: linkType.many.object.primaryKeyPropertyApiName,
-              object: linkType.many.object.apiName
-            },
-            column: linkType.many.object.primaryKeyPropertyApiName
-          }],
-          objectTypeBPrimaryKeyMapping: [{
-            property: {
-              apiName: linkType.toMany.object.primaryKeyPropertyApiName,
-              object: linkType.toMany.object.apiName
-            },
-            column: linkType.toMany.object.primaryKeyPropertyApiName
-          }]
-        }
-      },
-      editsConfiguration: {
-        onlyAllowPrivilegedEdits: false
+        },
+        pluralDisplayName: objectType.pluralDisplayName,
+        visibility: objectType.visibility ?? "NORMAL"
       },
-      redacted: linkType.redacted
-    };
+      primaryKeys: [objectType.primaryKeyPropertyApiName],
+      propertyTypes: Object.fromEntries(objectType.properties?.map((val) => [val.apiName, convertObjectPropertyType(val)]) ?? []),
+      titlePropertyTypeRid: objectType.titlePropertyApiName,
+      apiName: objectType.apiName,
+      status: convertObjectStatus(objectType.status),
+      redacted: false,
+      implementsInterfaces2: implementations.map((impl) => ({
+        interfaceTypeApiName: impl.implements.apiName,
+        linksV2: {},
+        propertiesV2: {},
+        properties: Object.fromEntries(impl.propertyMapping.map((mapping) => [addNamespaceIfNone(mapping.interfaceProperty), {
+          propertyTypeRid: mapping.mapsTo
+        }]))
+      })),
+      allImplementsInterfaces: {}
+    },
+    datasources: [...propertyDatasources, objectDatasource],
+    entityMetadata: {
+      arePatchesEnabled: objectType.editsEnabled ?? false
+    }
+  };
+}
+function extractMarkingGroups(properties, markingType) {
+  return properties.map((prop) => {
+    if (typeof prop.type === "object" && prop.type.type === "marking" && prop.type.markingType === markingType) {
+      return prop.type.markingInputGroupName;
+    }
+    return void 0;
+  }).filter((val) => val !== void 0);
+}
+function extractPropertyDatasource(property, objectTypeApiName) {
+  if (!isExotic(property.type)) {
+    return [];
+  }
+  const identifier = objectTypeApiName + "." + property.apiName;
+  switch (property.type) {
+    case "geotimeSeries":
+      const geotimeDefinition = {
+        type: "geotimeSeries",
+        geotimeSeries: {
+          geotimeSeriesIntegrationRid: identifier,
+          properties: [property.apiName]
+        }
+      };
+      return [buildDatasource(property.apiName, geotimeDefinition)];
+    case "mediaReference":
+      const mediaSetDefinition = {
+        type: "mediaSetView",
+        mediaSetView: {
+          assumedMarkings: [],
+          mediaSetViewLocator: identifier,
+          properties: [property.apiName]
+        }
+      };
+      return [buildDatasource(property.apiName, mediaSetDefinition)];
+    default:
+      return [];
+  }
+}
+
+// src/conversion/toMarketplace/convertOntologyDefinitionToWireBlockData.ts
+function convertOntologyDefinitionToWireBlockData(ontology) {
+  return {
+    objectTypes: Object.fromEntries(Object.entries(ontology[OntologyEntityTypeEnum.OBJECT_TYPE]).map(([apiName, objectType]) => {
+      return [apiName, convertObject(objectType)];
+    })),
+    sharedPropertyTypes: Object.fromEntries(Object.entries(ontology[OntologyEntityTypeEnum.SHARED_PROPERTY_TYPE]).map(([apiName, spt]) => [apiName, {
+      sharedPropertyType: convertSpt(spt)
+    }])),
+    interfaceTypes: Object.fromEntries(Object.entries(ontology[OntologyEntityTypeEnum.INTERFACE_TYPE]).map(([apiName, interfaceType]) => {
+      return [apiName, {
+        interfaceType: convertInterface(interfaceType)
+      }];
+    })),
+    linkTypes: Object.fromEntries(Object.entries(ontology[OntologyEntityTypeEnum.LINK_TYPE]).map(([id, link]) => {
+      return [cleanAndValidateLinkTypeId(id), convertLink(link)];
+    })),
+    actionTypes: Object.fromEntries(Object.entries(ontology[OntologyEntityTypeEnum.ACTION_TYPE]).map(([apiName, action]) => {
+      return [apiName, convertAction(action)];
+    })),
+    blockPermissionInformation: {
+      actionTypes: Object.fromEntries(Object.entries(ontology[OntologyEntityTypeEnum.ACTION_TYPE]).filter(([apiName, action]) => action.validation).map(([apiName, action]) => {
+        return [apiName, {
+          restrictionStatus: {
+            hasRolesApplied: true,
+            ontologyPackageRid: null,
+            publicProject: false
+          }
+        }];
+      })),
+      linkTypes: {},
+      objectTypes: {}
+    }
+  };
+}
+
+// src/conversion/toMarketplace/convertValueTypesToIr.ts
+function convertValueTypesToIr(valueTypes) {
+  return Object.values(valueTypes).map((definitions) => ({
+    metadata: {
+      apiName: definitions[0].apiName,
+      packageNamespace: definitions[0].packageNamespace,
+      displayMetadata: definitions[0].displayMetadata,
+      status: definitions[0].status
+    },
+    // TODO(dpaquin): instead of deduping here, we should refactor the value type types from arrays to maps
+    versions: Array.from(new Map(definitions.map((definition) => [definition.version, definition])).values()).map((definition) => ({
+      version: definition.version,
+      baseType: definition.baseType,
+      constraints: definition.constraints,
+      exampleValues: definition.exampleValues
+    }))
+  }));
+}
+
+// src/conversion/toMarketplace/convertOntologyToValueTypeIr.ts
+function convertOntologyToValueTypeIr(ontology) {
+  return {
+    valueTypes: convertValueTypesToIr(ontology[OntologyEntityTypeEnum.VALUE_TYPE])
+  };
+}
+
+// src/conversion/toMarketplace/convertOntologyDefinition.ts
+function convertOntologyDefinition(ontology, randomnessKey) {
+  return {
+    ontology: convertOntologyDefinitionToWireBlockData(ontology),
+    importedOntology: convertOntologyDefinitionToWireBlockData(importedTypes),
+    valueTypes: convertOntologyToValueTypeIr(ontology),
+    importedValueTypes: convertOntologyToValueTypeIr(importedTypes),
+    randomnessKey
+  };
+}
+
+// src/conversion/toMarketplace/getFormContentOrdering.ts
+function getFormContentOrdering(action, parameterOrdering) {
+  if (!action.sections) return [];
+  const parametersToSection = Object.fromEntries(Object.entries(action.sections).flatMap(([sectionId, section]) => section.parameters.map((param) => [param, sectionId])));
+  const seenIds = /* @__PURE__ */ new Set();
+  const formContentOrdering = [];
+  parameterOrdering.forEach((param) => {
+    if (param in parametersToSection && !seenIds.has(parametersToSection[param])) {
+      formContentOrdering.push({
+        type: "sectionId",
+        sectionId: parametersToSection[param]
+      });
+      seenIds.add(parametersToSection[param]);
+    } else if (!(param in parametersToSection)) {
+      formContentOrdering.push({
+        type: "parameterId",
+        parameterId: param
+      });
+      seenIds.add(param);
+    }
+  });
+  return formContentOrdering;
+}
+
+// src/api/defineOntology.ts
+var ontologyDefinition;
+var importedTypes;
+var dependencies;
+var namespace;
+function updateOntology(entity) {
+  if (entity.__type !== OntologyEntityTypeEnum.VALUE_TYPE) {
+    ontologyDefinition[entity.__type][entity.apiName] = entity;
+    return;
+  }
+  if (ontologyDefinition[OntologyEntityTypeEnum.VALUE_TYPE][entity.apiName] === void 0) {
+    ontologyDefinition[OntologyEntityTypeEnum.VALUE_TYPE][entity.apiName] = [];
+  }
+  ontologyDefinition[OntologyEntityTypeEnum.VALUE_TYPE][entity.apiName].push(entity);
+}
+async function defineOntology(ns, body, outputDir, dependencyFile, randomnessKey) {
+  namespace = ns;
+  dependencies = {};
+  ontologyDefinition = {
+    OBJECT_TYPE: {},
+    ACTION_TYPE: {},
+    LINK_TYPE: {},
+    INTERFACE_TYPE: {},
+    SHARED_PROPERTY_TYPE: {},
+    VALUE_TYPE: {}
+  };
+  importedTypes = {
+    SHARED_PROPERTY_TYPE: {},
+    OBJECT_TYPE: {},
+    ACTION_TYPE: {},
+    LINK_TYPE: {},
+    INTERFACE_TYPE: {},
+    VALUE_TYPE: {}
+  };
+  try {
+    await body();
+  } catch (e) {
+    console.error("Unexpected error while processing the body of the ontology", e);
+    throw e;
+  }
+  if (outputDir) {
+    writeStaticObjects(outputDir);
+  }
+  if (dependencyFile) {
+    writeDependencyFile(dependencyFile);
+  }
+  return convertOntologyDefinition(ontologyDefinition, randomnessKey);
+}
+function writeStaticObjects(outputDir) {
+  const codegenDir = path2__namespace.resolve(outputDir, "codegen");
+  const typeDirs = {
+    [OntologyEntityTypeEnum.SHARED_PROPERTY_TYPE]: "shared-property-types",
+    [OntologyEntityTypeEnum.ACTION_TYPE]: "action-types",
+    [OntologyEntityTypeEnum.OBJECT_TYPE]: "object-types",
+    [OntologyEntityTypeEnum.LINK_TYPE]: "link-types",
+    [OntologyEntityTypeEnum.INTERFACE_TYPE]: "interface-types",
+    [OntologyEntityTypeEnum.VALUE_TYPE]: "value-types"
+  };
+  if (!fs__namespace.existsSync(codegenDir)) {
+    fs__namespace.mkdirSync(codegenDir, {
+      recursive: true
+    });
+  }
+  Object.values(typeDirs).forEach((typeDirNameFromMap) => {
+    const currentTypeDirPath = path2__namespace.join(codegenDir, typeDirNameFromMap);
+    if (fs__namespace.existsSync(currentTypeDirPath)) {
+      fs__namespace.rmSync(currentTypeDirPath, {
+        recursive: true,
+        force: true
+      });
+    }
+    fs__namespace.mkdirSync(currentTypeDirPath, {
+      recursive: true
+    });
+  });
+  const topLevelExportStatements = [];
+  Object.entries(ontologyDefinition).forEach(([ontologyTypeEnumKey, entities]) => {
+    const typeDirName = typeDirs[ontologyTypeEnumKey];
+    const typeDirPath = path2__namespace.join(codegenDir, typeDirName);
+    const entityModuleNames = [];
+    Object.entries(entities).forEach(([apiName, entity]) => {
+      const entityFileNameBase = camel(withoutNamespace(apiName)) + (ontologyTypeEnumKey === OntologyEntityTypeEnum.VALUE_TYPE ? "ValueType" : "");
+      const filePath = path2__namespace.join(typeDirPath, `${entityFileNameBase}.ts`);
+      const entityTypeName = getEntityTypeName(ontologyTypeEnumKey);
+      const entityJSON = JSON.stringify(entity, null, 2).replace(/("__type"\s*:\s*)"([^"]*)"/g, (_, prefix, value) => `${prefix}OntologyEntityTypeEnum.${value}`);
+      const content = `
+import { wrapWithProxy, OntologyEntityTypeEnum } from '@osdk/maker';
+import type { ${entityTypeName} } from '@osdk/maker';
+
+const ${entityFileNameBase}_base: ${entityTypeName} = ${ontologyTypeEnumKey === "VALUE_TYPE" ? entityJSON.slice(1, -2) : entityJSON} as unknown as ${entityTypeName};
+        
+export const ${entityFileNameBase}: ${entityTypeName} = wrapWithProxy(${entityFileNameBase}_base);
+        `;
+      fs__namespace.writeFileSync(filePath, content, {
+        flag: "w"
+      });
+      entityModuleNames.push(entityFileNameBase);
+    });
+    for (const entityModuleName of entityModuleNames) {
+      topLevelExportStatements.push(`export { ${entityModuleName} } from "./codegen/${typeDirName}/${entityModuleName}.js";`);
+    }
+  });
+  if (topLevelExportStatements.length > 0) {
+    const mainIndexContent = dependencyInjectionString() + topLevelExportStatements.join("\n") + "\n";
+    const mainIndexFilePath = path2__namespace.join(outputDir, "index.ts");
+    fs__namespace.writeFileSync(mainIndexFilePath, mainIndexContent, {
+      flag: "w"
+    });
   }
+}
+function buildDatasource(apiName, definition, classificationMarkingGroupName, mandatoryMarkingGroupName) {
+  const needsSecurity = classificationMarkingGroupName !== void 0 || mandatoryMarkingGroupName !== void 0;
+  const securityConfig = needsSecurity ? {
+    classificationConstraint: classificationMarkingGroupName ? {
+      markingGroupName: classificationMarkingGroupName
+    } : void 0,
+    markingConstraint: mandatoryMarkingGroupName ? {
+      markingGroupName: mandatoryMarkingGroupName
+    } : void 0
+  } : void 0;
   return {
-    linkType: {
-      definition,
-      id: cleanAndValidateLinkTypeId(linkType.apiName),
-      status: linkType.status ?? {
-        type: "active",
-        active: {}
-      },
-      redacted: linkType.redacted ?? false
+    datasourceName: apiName,
+    datasource: definition,
+    editsConfiguration: {
+      onlyAllowPrivilegedEdits: false
     },
-    datasources: datasource !== void 0 ? [datasource] : [],
-    entityMetadata: {
-      arePatchesEnabled: linkType.editsEnabled ?? false
+    redacted: false,
+    ...securityConfig !== void 0 && {
+      dataSecurity: securityConfig
     }
   };
 }
@@ -1128,73 +1369,8 @@ function cleanAndValidateLinkTypeId(apiName) {
   }
   return linkTypeId;
 }
-function convertInterface(interfaceType) {
-  const {
-    __type,
-    ...other
-  } = interfaceType;
-  return {
-    ...other,
-    propertiesV2: Object.fromEntries(Object.values(interfaceType.propertiesV2).map((spt) => [spt.sharedPropertyType.apiName, {
-      required: spt.required,
-      sharedPropertyType: convertSpt(spt.sharedPropertyType)
-    }])),
-    displayMetadata: {
-      displayName: interfaceType.displayMetadata.displayName,
-      description: interfaceType.displayMetadata.description
-    },
-    extendsInterfaces: interfaceType.extendsInterfaces.map((i) => i.apiName),
-    // these are omitted from our internal types but we need to re-add them for the final json
-    properties: [],
-    // TODO(mwalther): Support propertiesV3
-    propertiesV3: {}
-  };
-}
 function dumpOntologyFullMetadata() {
-  return convertToWireOntologyIr(ontologyDefinition);
-}
-function convertSpt({
-  type,
-  array,
-  description,
-  apiName,
-  displayName,
-  visibility,
-  gothamMapping,
-  typeClasses,
-  valueType,
-  nullability
-}) {
-  const dataConstraint = convertNullabilityToDataConstraint({
-    type,
-    nullability
-  });
-  return {
-    apiName,
-    displayMetadata: {
-      displayName: displayName ?? apiName,
-      visibility: visibility ?? "NORMAL",
-      description
-    },
-    type: array ? {
-      type: "array",
-      array: {
-        subtype: convertType(type)
-      }
-    } : convertType(type),
-    aliases: [],
-    baseFormatter: void 0,
-    dataConstraints: dataConstraint,
-    gothamMapping,
-    indexedForSearch: true,
-    typeClasses: typeClasses ?? [],
-    valueType: valueType === void 0 ? void 0 : {
-      apiName: valueType.apiName,
-      version: valueType.version,
-      packageNamespace: valueType.packageNamespace,
-      displayMetadata: valueType.displayMetadata
-    }
-  };
+  return convertOntologyDefinition(ontologyDefinition);
 }
 function convertObjectStatus(status) {
   if (status === void 0) {
@@ -1241,143 +1417,54 @@ function convertAction(action) {
         validation: actionValidation
       },
       metadata: {
-        apiName: action.apiName,
-        displayMetadata: {
-          configuration: {
-            defaultLayout: action.defaultFormat ?? "FORM",
-            displayAndFormat: action.displayAndFormat ?? {
-              table: {
-                columnWidthByParameterRid: {},
-                enableFileImport: true,
-                fitHorizontally: false,
-                frozenColumnCount: 0,
-                rowHeightInLines: 1
-              }
-            },
-            enableLayoutUserSwitch: action.enableLayoutSwitch ?? false
-          },
-          description: action.description ?? "",
-          displayName: action.displayName,
-          icon: {
-            type: "blueprint",
-            blueprint: action.icon ?? {
-              locator: "edit",
-              color: "#000000"
-            }
-          },
-          successMessage: action.submissionMetadata?.successMessage ? [{
-            type: "message",
-            message: action.submissionMetadata.successMessage
-          }] : [],
-          typeClasses: action.typeClasses ?? [],
-          ...action.submissionMetadata?.submitButtonDisplayMetadata && {
-            submitButtonDisplayMetadata: action.submissionMetadata.submitButtonDisplayMetadata
-          },
-          ...action.submissionMetadata?.undoButtonConfiguration && {
-            undoButtonConfiguration: action.submissionMetadata.undoButtonConfiguration
-          }
-        },
-        parameterOrdering,
-        formContentOrdering: getFormContentOrdering(action, parameterOrdering),
-        parameters: actionParameters,
-        sections: actionSections,
-        status: typeof action.status === "string" ? {
-          type: action.status,
-          [action.status]: {}
-        } : action.status,
-        entities: action.entities
-      }
-    }
-  };
-}
-function convertActionValidation(action) {
-  return {
-    actionTypeLevelValidation: {
-      rules: Object.fromEntries((action.validation ?? [{
-        condition: {
-          type: "true",
-          true: {}
-        },
-        displayMetadata: {
-          failureMessage: "",
-          typeClasses: []
-        }
-      }]).map((rule, idx) => [idx, rule]))
-    },
-    parameterValidations: Object.fromEntries((action.parameters ?? []).map((p) => {
-      return [p.id, {
-        defaultValidation: {
-          display: {
-            renderHint: renderHintFromBaseType(p),
-            visibility: convertActionVisibility(p.validation.defaultVisibility),
-            ...p.defaultValue && {
-              prefill: p.defaultValue
-            }
-          },
-          validation: {
-            allowedValues: extractAllowedValues(p.validation.allowedValues),
-            required: convertParameterRequirementConstraint(p.validation.required)
-          }
-        },
-        conditionalOverrides: p.validation.conditionalOverrides?.map((override) => convertActionParameterConditionalOverride(override, p.validation)) ?? []
-      }];
-    })),
-    sectionValidations: {
-      ...Object.fromEntries(Object.entries(action.sections ?? {}).map(([sectionId, section]) => [section.id, {
-        defaultDisplayMetadata: section.defaultVisibility === "hidden" ? {
-          visibility: {
-            type: "hidden",
-            hidden: {}
-          }
-        } : {
-          visibility: {
-            type: "visible",
-            visible: {}
-          }
-        },
-        conditionalOverrides: section.conditionalOverrides?.map((override) => convertSectionConditionalOverride(override, section.defaultVisibility ?? "visible")) ?? []
-      }]))
-    }
-  };
-}
-function convertActionParameters(action) {
-  return Object.fromEntries((action.parameters ?? []).map((p) => [p.id, {
-    id: p.id,
-    type: typeof p.type === "string" ? {
-      type: p.type,
-      [p.type]: {}
-    } : p.type,
-    displayMetadata: {
-      displayName: p.displayName,
-      description: p.description ?? "",
-      typeClasses: []
-    }
-  }]));
-}
-function convertActionSections(action) {
-  return Object.fromEntries(Object.entries(action.sections ?? {}).map(([sectionId, section]) => [sectionId, {
-    id: sectionId,
-    content: section.parameters.map((p) => ({
-      type: "parameterId",
-      parameterId: p
-    })),
-    displayMetadata: {
-      collapsedByDefault: section.collapsedByDefault ?? false,
-      columnCount: section.columnCount ?? 1,
-      description: section.description ?? "",
-      displayName: section.displayName ?? convertToDisplayName(sectionId),
-      showTitleBar: section.showTitleBar ?? true,
-      ...section.style && {
-        style: section.style === "box" ? {
-          type: "box",
-          box: {}
-        } : {
-          type: "minimal",
-          minimal: {}
-        }
+        apiName: action.apiName,
+        displayMetadata: {
+          configuration: {
+            defaultLayout: action.defaultFormat ?? "FORM",
+            displayAndFormat: action.displayAndFormat ?? {
+              table: {
+                columnWidthByParameterRid: {},
+                enableFileImport: true,
+                fitHorizontally: false,
+                frozenColumnCount: 0,
+                rowHeightInLines: 1
+              }
+            },
+            enableLayoutUserSwitch: action.enableLayoutSwitch ?? false
+          },
+          description: action.description ?? "",
+          displayName: action.displayName,
+          icon: {
+            type: "blueprint",
+            blueprint: action.icon ?? {
+              locator: "edit",
+              color: "#000000"
+            }
+          },
+          successMessage: action.submissionMetadata?.successMessage ? [{
+            type: "message",
+            message: action.submissionMetadata.successMessage
+          }] : [],
+          typeClasses: action.typeClasses ?? [],
+          ...action.submissionMetadata?.submitButtonDisplayMetadata && {
+            submitButtonDisplayMetadata: action.submissionMetadata.submitButtonDisplayMetadata
+          },
+          ...action.submissionMetadata?.undoButtonConfiguration && {
+            undoButtonConfiguration: action.submissionMetadata.undoButtonConfiguration
+          }
+        },
+        parameterOrdering,
+        formContentOrdering: getFormContentOrdering(action, parameterOrdering),
+        parameters: actionParameters,
+        sections: actionSections,
+        status: typeof action.status === "string" ? {
+          type: action.status,
+          [action.status]: {}
+        } : action.status,
+        entities: action.entities
       }
     }
-  }]));
+  };
 }
 function extractAllowedValues(allowedValues) {
   switch (allowedValues.type) {
@@ -1576,31 +1663,6 @@ function renderHintFromBaseType(parameter) {
       throw new Error(`Unknown type ${type}`);
   }
 }
-function convertParameterRequirementConstraint(required) {
-  if (typeof required === "boolean") {
-    return required ? {
-      type: "required",
-      required: {}
-    } : {
-      type: "notRequired",
-      notRequired: {}
-    };
-  }
-  const {
-    min,
-    max
-  } = required.listLength;
-  return {
-    type: "listLengthValidation",
-    listLengthValidation: {
-      minLength: min,
-      maxLength: max
-    }
-  };
-}
-function sanitize(namespace2, s) {
-  return s.includes(".") ? s : namespace2 + s;
-}
 function withoutNamespace(apiName) {
   const lastDot = apiName.lastIndexOf(".");
   if (lastDot === -1) {
@@ -1639,17 +1701,11 @@ addDependency("${namespaceNoDot}", new URL(import.meta.url).pathname);
 function addNamespaceIfNone(apiName) {
   return apiName.includes(".") ? apiName : namespace + apiName;
 }
-function convertCardinality(cardinality) {
-  if (cardinality === "OneToMany" || cardinality === void 0) {
-    return "ONE_TO_MANY";
-  }
-  return "ONE_TO_ONE";
-}
 
 // src/cli/main.ts
 var apiNamespaceRegex = /^[a-z0-9-]+(\.[a-z0-9-]+)*\.$/;
 async function main(args = process.argv) {
-  const commandLineOpts = await yargs__default.default(helpers.hideBin(args)).version("0.13.0-beta.9").wrap(Math.min(150, yargs__default.default().terminalWidth())).strict().help().options({
+  const commandLineOpts = await yargs__default.default(helpers.hideBin(args)).version("0.13.0").wrap(Math.min(150, yargs__default.default().terminalWidth())).strict().help().options({
     input: {
       alias: "i",
       describe: "Input file",
@@ -1692,6 +1748,11 @@ async function main(args = process.argv) {
       describe: "File to write dependencies to",
       type: "string",
       coerce: path2__namespace.resolve
+    },
+    randomnessKey: {
+      describe: "Value used to assure uniqueness of entities",
+      type: "string",
+      coerce: path2__namespace.resolve
     }
   }).parseAsync();
   let apiNamespace = "";
@@ -1701,6 +1762,9 @@ async function main(args = process.argv) {
     !apiNamespaceRegex.test(apiNamespace) ? process.env.NODE_ENV !== "production" ? invariant5__default.default(false, "API namespace is invalid! It is expected to conform to ^[a-z0-9-]+(.[a-z0-9-]+)*.$") : invariant5__default.default(false) : void 0;
   }
   consola.consola.info(`Loading ontology from ${commandLineOpts.input}`);
+  if (commandLineOpts.randomnessKey !== void 0) {
+    !uuid.validate(commandLineOpts.randomnessKey) ? process.env.NODE_ENV !== "production" ? invariant5__default.default(false, "Supplied randomness key is not a uuid and shouldn't be used as a uniqueness guarantee") : invariant5__default.default(false) : void 0;
+  }
   const ontologyIr = await loadOntology(commandLineOpts.input, apiNamespace, commandLineOpts.outputDir, commandLineOpts.dependencies);
   consola.consola.info(`Saving ontology to ${commandLineOpts.output}`);
   await fs2__namespace.writeFile(commandLineOpts.output, JSON.stringify(ontologyIr, null, 2));
@@ -1732,36 +1796,68 @@ function addDependency(namespaceNoDot, fileInPackage) {
   const packageJson = JSON.parse(fs__namespace.readFileSync(packageJsonPath, "utf-8"));
   dependencies[namespaceNoDot] = packageJson.version ?? "";
 }
-function defineCreateInterfaceObjectAction(interfaceType, objectType, validation) {
-  const allProperties = Object.entries(getAllInterfaceProperties(interfaceType)).filter(([_, prop]) => !isStruct(prop.sharedPropertyType.type));
-  if (allProperties.length !== Object.entries(getAllInterfaceProperties(interfaceType)).length) {
-    consola.consola.info(`Some properties on ${interfaceType.apiName} were skipped in the create action because they are structs`);
+function convertMappingValue(value) {
+  switch (value.type) {
+    case "uuid":
+      return {
+        type: "uniqueIdentifier",
+        uniqueIdentifier: {
+          linkId: value.linkId ?? crypto.randomUUID()
+        }
+      };
+    case "currentTime":
+      return {
+        type: "currentTime",
+        currentTime: {}
+      };
+    case "currentUser":
+      return {
+        type: "currentUser",
+        currentUser: {}
+      };
+    default:
+      return value;
+  }
+}
+
+// src/api/action/ActionParameterType.ts
+function isActionParameterTypePrimitive(type) {
+  return ["boolean", "booleanList", "integer", "integerList", "long", "longList", "double", "doubleList", "string", "stringList", "decimal", "decimalList", "timestamp", "timestampList", "geohash", "geohashList", "geoshape", "geoshapeList", "timeSeriesReference", "date", "dateList", "objectTypeReference", "objectReference", "attachment", "attachmentList", "marking", "markingList", "mediaReference", "mediaReferenceList", "geotimeSeriesReference", "geotimeSeriesReferenceList"].includes(type);
+}
+
+// src/api/defineAction.ts
+var MODIFY_OBJECT_PARAMETER = "objectToModifyParameter";
+var CREATE_OR_MODIFY_OBJECT_PARAMETER = "objectToCreateOrModifyParameter";
+function defineCreateInterfaceObjectAction(def) {
+  const allProperties = Object.entries(getFlattenedInterfaceProperties(def.interfaceType)).filter(([_, prop]) => !isStruct(prop.sharedPropertyType.type) && !(def.excludedProperties ?? []).includes(prop.sharedPropertyType.nonNameSpacedApiName));
+  if (allProperties.length !== Object.entries(getFlattenedInterfaceProperties(def.interfaceType)).length) {
+    consola.consola.info(`Some properties on ${def.interfaceType.apiName} were skipped in the create action because they are structs`);
   }
   return defineAction({
-    apiName: `create-${kebab(interfaceType.apiName.split(".").pop() ?? interfaceType.apiName)}${objectType === void 0 ? "" : `-${kebab(objectType.apiName.split(".").pop() ?? objectType.apiName)}`}`,
-    displayName: `Create ${interfaceType.displayMetadata.displayName}`,
+    apiName: `create-${kebab(def.interfaceType.apiName.split(".").pop() ?? def.interfaceType.apiName)}${def.objectType === void 0 ? "" : `-${kebab(def.objectType.apiName.split(".").pop() ?? def.objectType.apiName)}`}`,
+    displayName: `Create ${def.interfaceType.displayMetadata.displayName}`,
     parameters: [{
       id: "objectTypeParameter",
       displayName: "Object type to create",
       type: {
         type: "objectTypeReference",
         objectTypeReference: {
-          interfaceTypeRids: [interfaceType.apiName]
+          interfaceTypeRids: [def.interfaceType.apiName]
         }
       },
       validation: {
         required: true,
-        allowedValues: objectType === void 0 ? {
+        allowedValues: def.objectType === void 0 ? {
           type: "objectTypeReference",
-          interfaceTypes: [interfaceType.apiName]
+          interfaceTypes: [def.interfaceType.apiName]
         } : {
           type: "oneOf",
           oneOf: [{
-            label: objectType.displayName,
+            label: def.objectType.displayName,
             value: {
               type: "objectType",
               objectType: {
-                objectTypeId: objectType.apiName
+                objectTypeId: def.objectType.apiName
               }
             }
           }]
@@ -1779,9 +1875,9 @@ function defineCreateInterfaceObjectAction(interfaceType, objectType, validation
         allowedValues: extractAllowedValuesFromPropertyType(prop.sharedPropertyType.type)
       }
     }))],
-    status: interfaceType.status.type !== "deprecated" ? interfaceType.status.type : interfaceType.status,
+    status: def.interfaceType.status.type !== "deprecated" ? def.interfaceType.status.type : def.interfaceType.status,
     entities: {
-      affectedInterfaceTypes: [interfaceType.apiName],
+      affectedInterfaceTypes: [def.interfaceType.apiName],
       affectedObjectTypes: [],
       affectedLinkTypes: [],
       typeGroups: []
@@ -1789,7 +1885,7 @@ function defineCreateInterfaceObjectAction(interfaceType, objectType, validation
     rules: [{
       type: "addInterfaceRule",
       addInterfaceRule: {
-        interfaceApiName: interfaceType.apiName,
+        interfaceApiName: def.interfaceType.apiName,
         objectTypeParameter: "objectTypeParameter",
         sharedPropertyValues: Object.fromEntries(allProperties.map(([id, _prop]) => [id, {
           type: "parameterId",
@@ -1797,8 +1893,8 @@ function defineCreateInterfaceObjectAction(interfaceType, objectType, validation
         }]))
       }
     }],
-    ...validation ? {
-      validation: convertValidationRule(validation)
+    ...def.validation ? {
+      validation: convertValidationRule(def.validation)
     } : {}
   });
 }
@@ -1859,35 +1955,35 @@ function defineCreateObjectAction(def) {
     }
   });
 }
-function defineModifyInterfaceObjectAction(interfaceType, objectType, validation) {
-  const allProperties = Object.entries(getAllInterfaceProperties(interfaceType)).filter(([_, prop]) => !isStruct(prop.sharedPropertyType.type));
-  if (allProperties.length !== Object.entries(getAllInterfaceProperties(interfaceType)).length) {
-    consola.consola.info(`Some properties on ${interfaceType.apiName} were skipped in the modify action because they are structs`);
+function defineModifyInterfaceObjectAction(def) {
+  const allProperties = Object.entries(getFlattenedInterfaceProperties(def.interfaceType)).filter(([_, prop]) => !isStruct(prop.sharedPropertyType.type) && !(def.excludedProperties ?? []).includes(prop.sharedPropertyType.nonNameSpacedApiName));
+  if (allProperties.length !== Object.entries(getFlattenedInterfaceProperties(def.interfaceType)).length) {
+    consola.consola.info(`Some properties on ${def.interfaceType.apiName} were skipped in the modify action because they are structs`);
   }
   return defineAction({
-    apiName: `modify-${kebab(interfaceType.apiName.split(".").pop() ?? interfaceType.apiName)}${objectType === void 0 ? "" : `-${kebab(objectType.apiName.split(".").pop() ?? objectType.apiName)}`}`,
-    displayName: `Modify ${interfaceType.displayMetadata.displayName}`,
+    apiName: `modify-${kebab(def.interfaceType.apiName.split(".").pop() ?? def.interfaceType.apiName)}${def.objectType === void 0 ? "" : `-${kebab(def.objectType.apiName.split(".").pop() ?? def.objectType.apiName)}`}`,
+    displayName: `Modify ${def.interfaceType.displayMetadata.displayName}`,
     parameters: [{
       id: "interfaceObjectToModifyParameter",
       displayName: "Object type to modify",
       type: {
         type: "interfaceReference",
         interfaceReference: {
-          interfaceTypeRid: interfaceType.apiName
+          interfaceTypeRid: def.interfaceType.apiName
         }
       },
       validation: {
         required: true,
-        allowedValues: objectType === void 0 ? {
+        allowedValues: def.objectType === void 0 ? {
           type: "interfaceObjectQuery"
         } : {
           type: "oneOf",
           oneOf: [{
-            label: objectType.displayName,
+            label: def.objectType.displayName,
             value: {
               type: "objectType",
               objectType: {
-                objectTypeId: objectType.apiName
+                objectTypeId: def.objectType.apiName
               }
             }
           }]
@@ -1905,9 +2001,9 @@ function defineModifyInterfaceObjectAction(interfaceType, objectType, validation
         allowedValues: extractAllowedValuesFromPropertyType(prop.sharedPropertyType.type)
       }
     }))],
-    status: interfaceType.status.type !== "deprecated" ? interfaceType.status.type : interfaceType.status,
+    status: def.interfaceType.status.type !== "deprecated" ? def.interfaceType.status.type : def.interfaceType.status,
     entities: {
-      affectedInterfaceTypes: [interfaceType.apiName],
+      affectedInterfaceTypes: [def.interfaceType.apiName],
       affectedObjectTypes: [],
       affectedLinkTypes: [],
       typeGroups: []
@@ -1922,8 +2018,8 @@ function defineModifyInterfaceObjectAction(interfaceType, objectType, validation
         }]))
       }
     }],
-    ...validation ? {
-      validation: convertValidationRule(validation)
+    ...def.validation ? {
+      validation: convertValidationRule(def.validation)
     } : {}
   });
 }
@@ -2131,6 +2227,23 @@ function defineAction(actionDef) {
     if (rule.type === "deleteObjectRule") {
       !parameterIds.some((id) => id === rule.deleteObjectRule.objectToDelete) ? process.env.NODE_ENV !== "production" ? invariant5__default.default(false, `Object to delete parameter must be defined in parameters`) : invariant5__default.default(false) : void 0;
     }
+    if (rule.type === "modifyInterfaceRule") {
+      const interfaceParam = actionDef.parameters.find((p) => p.id === rule.modifyInterfaceRule.interfaceObjectToModifyParameter);
+      !(interfaceParam !== void 0 && typeof interfaceParam.type === "object" && (interfaceParam.type.type === "interfaceReference" || interfaceParam.type.type === "interfaceReferenceList")) ? process.env.NODE_ENV !== "production" ? invariant5__default.default(false, `Interface object to modify parameter must be an interface reference`) : invariant5__default.default(false) : void 0;
+      const interfaceReference = interfaceParam.type.type === "interfaceReference" ? interfaceParam.type.interfaceReference.interfaceTypeRid : interfaceParam.type.interfaceReferenceList.interfaceTypeRid;
+      !(ontologyDefinition.INTERFACE_TYPE[interfaceReference] !== void 0 || importedTypes.INTERFACE_TYPE[interfaceReference] !== void 0) ? process.env.NODE_ENV !== "production" ? invariant5__default.default(false, `Interface type ${interfaceReference} does not exist`) : invariant5__default.default(false) : void 0;
+      const interfaceType = ontologyDefinition.INTERFACE_TYPE[interfaceReference];
+      Object.keys(rule.modifyInterfaceRule.sharedPropertyValues).forEach((spt) => {
+        !Object.keys(getFlattenedInterfaceProperties(interfaceType)).includes(spt) ? process.env.NODE_ENV !== "production" ? invariant5__default.default(false, `Shared property type ${spt} does not exist in interface type ${interfaceReference}`) : invariant5__default.default(false) : void 0;
+      });
+    }
+    if (rule.type === "addInterfaceRule") {
+      const interfaceType = ontologyDefinition.INTERFACE_TYPE[rule.addInterfaceRule.interfaceApiName] ?? importedTypes.INTERFACE_TYPE[rule.addInterfaceRule.interfaceApiName];
+      !(interfaceType !== void 0) ? process.env.NODE_ENV !== "production" ? invariant5__default.default(false, `Interface type ${rule.addInterfaceRule.interfaceApiName} does not exist`) : invariant5__default.default(false) : void 0;
+      Object.keys(rule.addInterfaceRule.sharedPropertyValues).forEach((spt) => {
+        !Object.keys(getFlattenedInterfaceProperties(interfaceType)).includes(spt) ? process.env.NODE_ENV !== "production" ? invariant5__default.default(false, `Shared property type ${spt} does not exist in interface type ${interfaceType.apiName}`) : invariant5__default.default(false) : void 0;
+      });
+    }
   });
   const fullAction = {
     ...actionDef,
@@ -2204,7 +2317,7 @@ function createParameters(def, parameterSet) {
   });
   return [...targetParam, ...Array.from(parameterSet).map((id) => ({
     id,
-    displayName: def.parameterConfiguration?.[id]?.displayName ?? def.objectType.properties?.[id]?.displayName ?? convertToDisplayName(id),
+    displayName: def.parameterConfiguration?.[id]?.displayName ?? def.objectType.properties?.[id]?.displayName ?? uppercaseFirstLetter(id),
     type: def.parameterConfiguration?.[id]?.customParameterType ?? extractActionParameterType(def.objectType.properties?.[id]),
     validation: def.parameterConfiguration?.[id] !== void 0 ? {
       ...def.parameterConfiguration?.[id],
@@ -2233,14 +2346,14 @@ function referencedParameterIds(actionDef) {
   actionDef.rules.forEach((rule) => {
     switch (rule.type) {
       case "addInterfaceRule":
-        rule.addInterfaceRule.interfaceApiName = sanitize2(rule.addInterfaceRule.interfaceApiName);
+        rule.addInterfaceRule.interfaceApiName = sanitize(rule.addInterfaceRule.interfaceApiName);
         parameterIds.add(rule.addInterfaceRule.objectTypeParameter);
         Object.entries(rule.addInterfaceRule.sharedPropertyValues).forEach(([k, v]) => {
           if (v.type === "parameterId") {
             parameterIds.add(v.parameterId);
           }
           delete rule.addInterfaceRule.sharedPropertyValues[k];
-          rule.addInterfaceRule.sharedPropertyValues[sanitize2(k)] = v;
+          rule.addInterfaceRule.sharedPropertyValues[sanitize(k)] = v;
         });
         break;
       case "modifyInterfaceRule":
@@ -2250,7 +2363,7 @@ function referencedParameterIds(actionDef) {
             parameterIds.add(v.parameterId);
           }
           delete rule.modifyInterfaceRule.sharedPropertyValues[k];
-          rule.modifyInterfaceRule.sharedPropertyValues[sanitize2(k)] = v;
+          rule.modifyInterfaceRule.sharedPropertyValues[sanitize(k)] = v;
         });
         break;
       case "addObjectRule":
@@ -2479,16 +2592,10 @@ function extractActionParameterType(pt) {
 function maybeAddList(type, pt) {
   return pt.array ?? false ? type + "List" : type;
 }
-function isActionParameterTypePrimitive(type) {
-  return ["boolean", "booleanList", "integer", "integerList", "long", "longList", "double", "doubleList", "string", "stringList", "decimal", "decimalList", "timestamp", "timestampList", "geohash", "geohashList", "geoshape", "geoshapeList", "timeSeriesReference", "date", "dateList", "objectTypeReference", "objectReference", "attachment", "attachmentList", "marking", "markingList", "mediaReference", "mediaReferenceList", "geotimeSeriesReference", "geotimeSeriesReferenceList"].includes(type);
-}
-function isStruct(type) {
-  return typeof type === "object" && type.type === "struct";
-}
 function kebab(s) {
   return s.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").replace(/\./g, "-").toLowerCase();
 }
-function sanitize2(s) {
+function sanitize(s) {
   return s.includes(".") ? s : namespace + s;
 }
 function convertValidationRule(actionValidation) {
@@ -2585,42 +2692,6 @@ function validateParameterOrdering(parameterOrdering, parameterSet, actionApiNam
   const extraneousParameters = parameterOrdering.filter((param) => !parameterSet.has(param));
   !(extraneousParameters.length === 0 && missingParameters.length === 0) ? process.env.NODE_ENV !== "production" ? invariant5__default.default(false, `Action parameter ordering for ${actionApiName} does not match expected parameters. Extraneous parameters in ordering: {${extraneousParameters}}, Missing parameters in ordering: {${missingParameters}}`) : invariant5__default.default(false) : void 0;
 }
-
-// src/api/importOntologyEntity.ts
-function importOntologyEntity(e) {
-  if (e.__type !== OntologyEntityTypeEnum.VALUE_TYPE) {
-    importedTypes[e.__type][e.apiName] = e;
-    return;
-  }
-  if (importedTypes[OntologyEntityTypeEnum.VALUE_TYPE][e.apiName] === void 0) {
-    importedTypes[OntologyEntityTypeEnum.VALUE_TYPE][e.apiName] = [];
-  }
-  importedTypes[OntologyEntityTypeEnum.VALUE_TYPE][e.apiName].push(e);
-}
-
-// src/api/defineImportSpt.ts
-function importSharedPropertyType(opts) {
-  const {
-    apiName,
-    packageName,
-    typeHint,
-    array
-  } = opts;
-  const fullApiName = packageName === void 0 ? apiName : `${packageName}.${apiName}`;
-  if (packageName !== void 0) {
-    !!packageName.endsWith(".") ? process.env.NODE_ENV !== "production" ? invariant5__default.default(false, "Package name format invalid ends with period") : invariant5__default.default(false) : void 0;
-    !(packageName.match("[A-Z]") == null) ? process.env.NODE_ENV !== "production" ? invariant5__default.default(false, "Package name includes upper case characters") : invariant5__default.default(false) : void 0;
-  }
-  const spt = {
-    apiName: fullApiName,
-    type: typeHint,
-    nonNameSpacedApiName: apiName,
-    array: array ?? false,
-    __type: OntologyEntityTypeEnum.SHARED_PROPERTY_TYPE
-  };
-  importOntologyEntity(spt);
-  return spt;
-}
 function defineSharedPropertyType(sptDef) {
   const apiName = namespace + sptDef.apiName;
   !(ontologyDefinition[OntologyEntityTypeEnum.SHARED_PROPERTY_TYPE][apiName] === void 0) ? process.env.NODE_ENV !== "production" ? invariant5__default.default(false, `Shared property type ${apiName} already exists`) : invariant5__default.default(false) : void 0;
@@ -2638,20 +2709,54 @@ function defineSharedPropertyType(sptDef) {
   return fullSpt;
 }
 
+// src/api/interface/mapSimplifiedStatusToInterfaceTypeStatus.ts
+function mapSimplifiedStatusToInterfaceTypeStatus(status) {
+  switch (status.type) {
+    case "deprecated":
+      return {
+        type: "deprecated",
+        deprecated: {
+          message: status.message,
+          deadline: status.deadline,
+          replacedBy: void 0
+        }
+      };
+    case "active":
+      return {
+        type: "active",
+        active: {}
+      };
+    case "experimental":
+      return {
+        type: "experimental",
+        experimental: {}
+      };
+    default:
+      throw new Error(`Invalid status type: ${status.type}`);
+  }
+}
+
+// src/api/namespace/combineApiNamespaceIfMissing.ts
+function combineApiNamespaceIfMissing(namespace2, apiName) {
+  return apiName.includes(".") ? apiName : namespace2 + apiName;
+}
+
 // src/api/defineInterface.ts
 function defineInterface(interfaceDef) {
   const apiName = namespace + interfaceDef.apiName;
   !(ontologyDefinition[OntologyEntityTypeEnum.INTERFACE_TYPE][apiName] === void 0) ? process.env.NODE_ENV !== "production" ? invariant5__default.default(false, `Interface ${apiName} already exists`) : invariant5__default.default(false) : void 0;
-  const properties = Object.fromEntries(Object.entries(interfaceDef.properties ?? {}).map(([propApiName, type]) => {
+  const properties = Object.fromEntries(Object.entries(interfaceDef.properties ?? {}).map(([unNamespacedPropApiName, type]) => {
     if (typeof type === "object" && "propertyDefinition" in type) {
-      return [namespace + propApiName, {
+      const apiName3 = combineApiNamespaceIfMissing(namespace, typeof type.propertyDefinition === "object" && "apiName" in type.propertyDefinition ? type.propertyDefinition.apiName : unNamespacedPropApiName);
+      return [apiName3, {
         required: type.required,
-        sharedPropertyType: unifyBasePropertyDefinition(namespace, propApiName, type.propertyDefinition)
+        sharedPropertyType: unifyBasePropertyDefinition(namespace, unNamespacedPropApiName, type.propertyDefinition)
       }];
     }
-    return [namespace + propApiName, {
+    const apiName2 = combineApiNamespaceIfMissing(namespace, typeof type === "object" && "apiName" in type ? type.apiName : unNamespacedPropApiName);
+    return [apiName2, {
       required: true,
-      sharedPropertyType: unifyBasePropertyDefinition(namespace, propApiName, type)
+      sharedPropertyType: unifyBasePropertyDefinition(namespace, unNamespacedPropApiName, type)
     }];
   }));
   const extendsInterfaces = interfaceDef.extends ? Array.isArray(interfaceDef.extends) ? interfaceDef.extends : [interfaceDef.extends] : [];
@@ -2682,34 +2787,6 @@ function defineInterface(interfaceDef) {
   updateOntology(fullInterface);
   return fullInterface;
 }
-function isPropertyTypeType(v) {
-  return v === "boolean" || v === "byte" || v === "date" || v === "decimal" || v === "double" || v === "float" || v === "geopoint" || v === "geoshape" || v === "integer" || v === "long" || typeof v === "object" && v.type === "marking" || v === "short" || v === "string" || v === "timestamp";
-}
-function mapSimplifiedStatusToInterfaceTypeStatus(status) {
-  switch (status.type) {
-    case "deprecated":
-      return {
-        type: "deprecated",
-        deprecated: {
-          message: status.message,
-          deadline: status.deadline,
-          replacedBy: void 0
-        }
-      };
-    case "active":
-      return {
-        type: "active",
-        active: {}
-      };
-    case "experimental":
-      return {
-        type: "experimental",
-        experimental: {}
-      };
-    default:
-      throw new Error(`Invalid status type: ${status.type}`);
-  }
-}
 function unifyBasePropertyDefinition(namespace2, apiName, type) {
   if (typeof type === "string" || typeof type === "object" && !("apiName" in type)) {
     !isPropertyTypeType(type) ? process.env.NODE_ENV !== "production" ? invariant5__default.default(false, `Invalid data type ${JSON.stringify(type)} for property ${apiName} on InterfaceType ${apiName}`) : invariant5__default.default(false) : void 0;
@@ -2751,7 +2828,7 @@ function getLinkMeta(meta) {
     displayName,
     description
   } = meta;
-  const apiNameWithNamespace = sanitize(namespace, apiName);
+  const apiNameWithNamespace = combineApiNamespaceIfMissing(namespace, apiName);
   const apiNameWithoutNamespace = withoutNamespace(apiNameWithNamespace);
   return {
     apiName: apiNameWithNamespace,
@@ -2768,15 +2845,30 @@ function defineLink(linkDefinition) {
     const typesMatch = foreignKey.type === linkDefinition.one.object.properties?.[linkDefinition.one.object.primaryKeyPropertyApiName].type;
     !typesMatch ? process.env.NODE_ENV !== "production" ? invariant5__default.default(false, `Link ${linkDefinition.apiName} has type mismatch between the one side's primary key and the foreign key on the many side`) : invariant5__default.default(false) : void 0;
   }
-  const fullLinkDefinition = "one" in linkDefinition ? {
-    ...linkDefinition,
-    one: convertUserOneToManyLinkDefinition(linkDefinition.one),
-    toMany: convertUserOneToManyLinkDefinition(linkDefinition.toMany)
-  } : {
-    ...linkDefinition,
-    many: convertUserManyToManyLinkDefinition(linkDefinition.many),
-    toMany: convertUserManyToManyLinkDefinition(linkDefinition.toMany)
-  };
+  if ("intermediaryObjectType" in linkDefinition) {
+    !("one" in linkDefinition.many.linkToIntermediary && linkDefinition.many.linkToIntermediary.one.object.apiName === linkDefinition.many.object.apiName && linkDefinition.many.linkToIntermediary.toMany.object.apiName === linkDefinition.intermediaryObjectType.apiName) ? process.env.NODE_ENV !== "production" ? invariant5__default.default(false, `LinkTypeA ${linkDefinition.many.linkToIntermediary.apiName} must be a many to one link from intermediary object ${linkDefinition.intermediaryObjectType.apiName} to objectA ${linkDefinition.many.object.apiName}`) : invariant5__default.default(false) : void 0;
+    !("one" in linkDefinition.toMany.linkToIntermediary && linkDefinition.toMany.linkToIntermediary.one.object.apiName === linkDefinition.toMany.object.apiName && linkDefinition.toMany.linkToIntermediary.toMany.object.apiName === linkDefinition.intermediaryObjectType.apiName) ? process.env.NODE_ENV !== "production" ? invariant5__default.default(false, `LinkTypeB ${linkDefinition.toMany.linkToIntermediary.apiName} must be a many to one link from intermediary object ${linkDefinition.intermediaryObjectType.apiName} to objectB ${linkDefinition.toMany.object.apiName}`) : invariant5__default.default(false) : void 0;
+  }
+  let fullLinkDefinition;
+  if ("one" in linkDefinition) {
+    fullLinkDefinition = {
+      ...linkDefinition,
+      one: convertUserOneToManyLinkDefinition(linkDefinition.one),
+      toMany: convertUserOneToManyLinkDefinition(linkDefinition.toMany)
+    };
+  } else if ("intermediaryObjectType" in linkDefinition) {
+    fullLinkDefinition = {
+      ...linkDefinition,
+      many: convertUserIntermediaryLinkDefinition(linkDefinition.many),
+      toMany: convertUserIntermediaryLinkDefinition(linkDefinition.toMany)
+    };
+  } else {
+    fullLinkDefinition = {
+      ...linkDefinition,
+      many: convertUserManyToManyLinkDefinition(linkDefinition.many),
+      toMany: convertUserManyToManyLinkDefinition(linkDefinition.toMany)
+    };
+  }
   const linkType = {
     cardinality: "one" in linkDefinition ? linkDefinition.cardinality : void 0,
     ...fullLinkDefinition,
@@ -2797,11 +2889,17 @@ function convertUserManyToManyLinkDefinition(manyToMany) {
     metadata: convertLinkTypeMetadata(manyToMany.metadata)
   };
 }
+function convertUserIntermediaryLinkDefinition(intermediary) {
+  return {
+    ...intermediary,
+    metadata: convertLinkTypeMetadata(intermediary.metadata)
+  };
+}
 function convertLinkTypeMetadata(metadata) {
   return {
     apiName: metadata.apiName,
     displayMetadata: {
-      displayName: metadata.displayName ?? convertToDisplayName(metadata.apiName),
+      displayName: metadata.displayName ?? uppercaseFirstLetter(metadata.apiName),
       pluralDisplayName: metadata.pluralDisplayName ?? convertToPluralDisplayName(metadata.apiName),
       visibility: metadata.visibility ?? "NORMAL",
       groupDisplayName: metadata.groupDisplayName ?? ""
@@ -2897,6 +2995,40 @@ function defineValueType(valueTypeDef) {
   return vt;
 }
 
+// src/api/importOntologyEntity.ts
+function importOntologyEntity(e) {
+  if (e.__type !== OntologyEntityTypeEnum.VALUE_TYPE) {
+    importedTypes[e.__type][e.apiName] = e;
+    return;
+  }
+  if (importedTypes[OntologyEntityTypeEnum.VALUE_TYPE][e.apiName] === void 0) {
+    importedTypes[OntologyEntityTypeEnum.VALUE_TYPE][e.apiName] = [];
+  }
+  importedTypes[OntologyEntityTypeEnum.VALUE_TYPE][e.apiName].push(e);
+}
+function importSharedPropertyType(opts) {
+  const {
+    apiName,
+    packageName,
+    typeHint,
+    array
+  } = opts;
+  const fullApiName = packageName === void 0 ? apiName : `${packageName}.${apiName}`;
+  if (packageName !== void 0) {
+    !!packageName.endsWith(".") ? process.env.NODE_ENV !== "production" ? invariant5__default.default(false, "Package name format invalid ends with period") : invariant5__default.default(false) : void 0;
+    !(packageName.match("[A-Z]") == null) ? process.env.NODE_ENV !== "production" ? invariant5__default.default(false, "Package name includes upper case characters") : invariant5__default.default(false) : void 0;
+  }
+  const spt = {
+    apiName: fullApiName,
+    type: typeHint,
+    nonNameSpacedApiName: apiName,
+    array: array ?? false,
+    __type: OntologyEntityTypeEnum.SHARED_PROPERTY_TYPE
+  };
+  importOntologyEntity(spt);
+  return spt;
+}
+
 // src/api/wrapWithProxy.ts
 function wrapWithProxy(entity) {
   return new Proxy(entity, {
@@ -2912,9 +3044,9 @@ exports.MODIFY_OBJECT_PARAMETER = MODIFY_OBJECT_PARAMETER;
 exports.OntologyEntityTypeEnum = OntologyEntityTypeEnum;
 exports.addDependency = addDependency;
 exports.addNamespaceIfNone = addNamespaceIfNone;
-exports.convertToDisplayName = convertToDisplayName;
+exports.convertToDisplayName = uppercaseFirstLetter;
 exports.convertToPluralDisplayName = convertToPluralDisplayName;
-exports.convertType = convertType;
+exports.convertType = propertyTypeTypeToOntologyIrType;
 exports.default = main;
 exports.defineAction = defineAction;
 exports.defineCreateInterfaceObjectAction = defineCreateInterfaceObjectAction;