@osdk/maker 0.13.0-beta.10 → 0.13.0-beta.12

package/build/cjs/index.cjs

@@ -39,7 +39,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 +65,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 +129,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 +144,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 +159,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 +181,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 +366,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 +411,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 +510,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 +543,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 +563,7 @@ function convertType(type) {
               },
               typeClasses: [],
               aliases: [],
-              fieldType: convertType(fieldTypeDefinition)
+              fieldType: propertyTypeTypeToOntologyIrType(fieldTypeDefinition)
             };
           }
         }
@@ -635,187 +624,415 @@ 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: {}
+// src/conversion/toMarketplace/convertSpt.ts
+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: 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
+    }
   };
-  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"
+
+// src/conversion/toMarketplace/convertInterface.ts
+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,
+      icon: interfaceType.displayMetadata.icon ?? {
+        type: "blueprint",
+        blueprint: {
+          color: "#4C90F0",
+          locator: "layout-hierarchy"
+        }
+      }
+    },
+    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: {}
   };
-  if (!fs__namespace.existsSync(codegenDir)) {
-    fs__namespace.mkdirSync(codegenDir, {
-      recursive: true
-    });
+}
+
+// src/conversion/toMarketplace/convertCardinality.ts
+function convertCardinality(cardinality) {
+  if (cardinality === "OneToMany" || cardinality === void 0) {
+    return "ONE_TO_MANY";
   }
-  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';
+  return "ONE_TO_ONE";
+}
 
-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/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 {
+    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 = {
+      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
+      },
+      redacted: linkType.redacted
+    };
+  }
+  return {
+    linkType: {
+      definition,
+      id: cleanAndValidateLinkTypeId(linkType.apiName),
+      status: linkType.status ?? {
+        type: "active",
+        active: {}
+      },
+      redacted: linkType.redacted ?? false
+    },
+    datasources: datasource !== void 0 ? [datasource] : [],
+    entityMetadata: {
+      arePatchesEnabled: linkType.editsEnabled ?? false
     }
-  });
-  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"
-    });
+  };
+}
+
+// src/conversion/toMarketplace/convertDatasourceDefinition.ts
+function convertDatasourceDefinition(objectType, properties) {
+  switch (objectType.datasource?.type) {
+    case "stream":
+      const window = objectType.datasource.retentionPeriod;
+      const retentionPolicy = window ? {
+        type: "time",
+        time: {
+          window
+        }
+      } : {
+        type: "none",
+        none: {}
+      };
+      const propertyMapping = Object.fromEntries(properties.map((prop) => [prop.apiName, prop.apiName]));
+      return {
+        type: "streamV2",
+        streamV2: {
+          streamLocator: objectType.apiName,
+          propertyMapping,
+          retentionPolicy,
+          propertySecurityGroups: void 0
+        }
+      };
+    case "restrictedView":
+      return {
+        type: "restrictedViewV2",
+        restrictedViewV2: {
+          restrictedViewRid: objectType.apiName,
+          propertyMapping: buildPropertyMapping(properties)
+        }
+      };
+    case "dataset":
+    default:
+      return {
+        type: "datasetV2",
+        datasetV2: {
+          datasetRid: objectType.apiName,
+          propertyMapping: buildPropertyMapping(properties)
+        }
+      };
   }
 }
-function convertOntologyToValueTypeIr(ontology) {
+function buildPropertyMapping(properties) {
+  return Object.fromEntries(properties.map((prop) => {
+    if (prop.editOnly) {
+      return [prop.apiName, {
+        type: "editOnly",
+        editOnly: {}
+      }];
+    }
+    if (typeof prop.type === "object" && prop.type?.type === "struct") {
+      const structMapping = {
+        type: "struct",
+        struct: {
+          column: prop.apiName,
+          mapping: Object.fromEntries(Object.keys(prop.type.structDefinition).map((fieldName) => [fieldName, {
+            apiName: fieldName,
+            mappings: {}
+          }]))
+        }
+      };
+      return [prop.apiName, structMapping];
+    }
+    return [prop.apiName, {
+      type: "column",
+      column: prop.apiName
+    }];
+  }));
+}
+
+// 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 {
-    valueTypes: convertValueTypesToIr(ontology[OntologyEntityTypeEnum.VALUE_TYPE])
+    propertyTypeConstraints: [{
+      constraints: dataConstraintToPropertyTypeDataConstraint(dc)
+      // known limitation: structs don't carry field-level data constraint failure messages
+    }]
   };
 }
-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/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}`);
+  }
 }
-function convertToWireOntologyIr(ontology) {
+
+// 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 {
-    ontology: convertToWireBlockData(ontology),
-    importedOntology: convertToWireBlockData(importedTypes),
-    valueTypes: convertOntologyToValueTypeIr(ontology),
-    importedValueTypes: convertOntologyToValueTypeIr(importedTypes)
+    propertyTypeConstraints
   };
 }
-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: {}
-    }
+
+// 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 = {
+    apiName: property.apiName,
+    sharedPropertyTypeApiName: property.sharedPropertyType?.apiName,
+    displayMetadata: {
+      displayName: property.displayName,
+      description: property.description,
+      visibility: property.visibility ?? "NORMAL"
+    },
+    indexedForSearch: property.indexedForSearch ?? true,
+    ruleSetBinding: void 0,
+    baseFormatter: property.baseFormatter,
+    type: property.array ? {
+      type: "array",
+      array: {
+        subtype: propertyTypeTypeToOntologyIrType(property.type)
+      }
+    } : propertyTypeTypeToOntologyIrType(property.type),
+    typeClasses: property.typeClasses ?? (shouldNotHaveRenderHints(property.type) ? [] : defaultTypeClasses),
+    status: convertObjectStatus(property.status),
+    inlineAction: void 0,
+    dataConstraints: property.valueType ? convertValueTypeDataConstraints(property.valueType.constraints) : convertNullabilityToDataConstraint(property),
+    sharedPropertyTypeRid: property.sharedPropertyType?.apiName,
+    valueType: property.valueType ? convertValueType(property.valueType) : void 0
   };
+  return output;
 }
+
+// src/conversion/toMarketplace/convertObject.ts
 function convertObject(objectType) {
   const propertyDatasources = (objectType.properties ?? []).flatMap((prop) => extractPropertyDatasource(prop, objectType.apiName));
   const classificationGroupMarkingNames = extractMarkingGroups(objectType.properties ?? [], "CBAC");
@@ -841,7 +1058,7 @@ function convertObject(objectType) {
         visibility: objectType.visibility ?? "NORMAL"
       },
       primaryKeys: [objectType.primaryKeyPropertyApiName],
-      propertyTypes: Object.fromEntries(objectType.properties?.map((val) => [val.apiName, convertProperty(val)]) ?? []),
+      propertyTypes: Object.fromEntries(objectType.properties?.map((val) => [val.apiName, convertObjectPropertyType(val)]) ?? []),
       titlePropertyTypeRid: objectType.titlePropertyApiName,
       apiName: objectType.apiName,
       status: convertObjectStatus(objectType.status),
@@ -856,104 +1073,11 @@ function convertObject(objectType) {
       })),
       allImplementsInterfaces: {}
     },
-    datasources: [...propertyDatasources, objectDatasource],
-    entityMetadata: {
-      arePatchesEnabled: objectType.editsEnabled ?? false
-    }
-  };
-}
-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 [];
-  }
-}
-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
-    },
-    redacted: false,
-    ...securityConfig !== void 0 && {
-      dataSecurity: securityConfig
-    }
-  };
-}
-function convertDatasourceDefinition(objectType, properties) {
-  switch (objectType.datasource?.type) {
-    case "stream":
-      const window = objectType.datasource.retentionPeriod;
-      const retentionPolicy = window ? {
-        type: "time",
-        time: {
-          window
-        }
-      } : {
-        type: "none",
-        none: {}
-      };
-      const propertyMapping = Object.fromEntries(properties.map((prop) => [prop.apiName, prop.apiName]));
-      return {
-        type: "streamV2",
-        streamV2: {
-          streamLocator: objectType.apiName,
-          propertyMapping,
-          retentionPolicy,
-          propertySecurityGroups: void 0
-        }
-      };
-    case "restrictedView":
-      return {
-        type: "restrictedViewV2",
-        restrictedViewV2: {
-          restrictedViewRid: objectType.apiName,
-          propertyMapping: buildPropertyMapping(properties)
-        }
-      };
-    case "dataset":
-    default:
-      return {
-        type: "datasetV2",
-        datasetV2: {
-          datasetRid: objectType.apiName,
-          propertyMapping: buildPropertyMapping(properties)
-        }
-      };
-  }
+    datasources: [...propertyDatasources, objectDatasource],
+    entityMetadata: {
+      arePatchesEnabled: objectType.editsEnabled ?? false
+    }
+  };
 }
 function extractMarkingGroups(properties, markingType) {
   return properties.map((prop) => {
@@ -963,159 +1087,261 @@ function extractMarkingGroups(properties, markingType) {
     return void 0;
   }).filter((val) => val !== void 0);
 }
-function buildPropertyMapping(properties) {
-  return Object.fromEntries(properties.map((prop) => {
-    if (prop.editOnly) {
-      return [prop.apiName, {
-        type: "editOnly",
-        editOnly: {}
-      }];
-    }
-    if (typeof prop.type === "object" && prop.type?.type === "struct") {
-      const structMapping = {
-        type: "struct",
-        struct: {
-          column: prop.apiName,
-          mapping: Object.fromEntries(Object.keys(prop.type.structDefinition).map((fieldName) => [fieldName, {
-            apiName: fieldName,
-            mappings: {}
-          }]))
+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 [prop.apiName, structMapping];
+      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 [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: {}
     }
-    return [prop.apiName, {
-      type: "column",
-      column: prop.apiName
-    }];
-  }));
+  };
 }
-function convertProperty(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 = {
-    apiName: property.apiName,
-    sharedPropertyTypeApiName: property.sharedPropertyType?.apiName,
-    displayMetadata: {
-      displayName: property.displayName,
-      description: property.description,
-      visibility: property.visibility ?? "NORMAL"
+
+// 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
     },
-    indexedForSearch: property.indexedForSearch ?? true,
-    ruleSetBinding: void 0,
-    baseFormatter: property.baseFormatter,
-    type: property.array ? {
-      type: "array",
-      array: {
-        subtype: convertType(property.type)
-      }
-    } : convertType(property.type),
-    typeClasses: property.typeClasses ?? (shouldNotHaveRenderHints(property.type) ? [] : defaultTypeClasses),
-    status: convertObjectStatus(property.status),
-    inlineAction: void 0,
-    dataConstraints: property.valueType ? convertValueTypeDataConstraints(property.valueType.constraints) : convertNullabilityToDataConstraint(property),
-    sharedPropertyTypeRid: property.sharedPropertyType?.apiName,
-    valueType: property.valueType ? convertValueType(property.valueType) : void 0
+    // 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])
   };
-  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
-          }
-        }]
-      }
-    };
-    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
-      },
-      redacted: linkType.redacted
-    };
+
+// src/conversion/toMarketplace/convertOntologyDefinition.ts
+function convertOntologyDefinition(ontology) {
+  return {
+    ontology: convertOntologyDefinitionToWireBlockData(ontology),
+    importedOntology: convertOntologyDefinitionToWireBlockData(importedTypes),
+    valueTypes: convertOntologyToValueTypeIr(ontology),
+    importedValueTypes: convertOntologyToValueTypeIr(importedTypes)
+  };
+}
+
+// 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) {
+  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);
+}
+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
+    rid: "ri.ontology.main.datasource.".concat(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 +1354,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) {
@@ -1263,121 +1424,32 @@ function convertAction(action) {
             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: {}
+            }
+          },
+          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
           }
         },
-        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: {}
-        }
+        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 +1648,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 +1686,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.10").wrap(Math.min(150, yargs__default.default().terminalWidth())).strict().help().options({
+  const commandLineOpts = await yargs__default.default(helpers.hideBin(args)).version("0.13.0-beta.12").wrap(Math.min(150, yargs__default.default().terminalWidth())).strict().help().options({
     input: {
       alias: "i",
       describe: "Input file",
@@ -1732,9 +1773,41 @@ function addDependency(namespaceNoDot, fileInPackage) {
   const packageJson = JSON.parse(fs__namespace.readFileSync(packageJsonPath, "utf-8"));
   dependencies[namespaceNoDot] = packageJson.version ?? "";
 }
+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(interfaceType, objectType, validation) {
-  const allProperties = Object.entries(getAllInterfaceProperties(interfaceType)).filter(([_, prop]) => !isStruct(prop.sharedPropertyType.type));
-  if (allProperties.length !== Object.entries(getAllInterfaceProperties(interfaceType)).length) {
+  const allProperties = Object.entries(getFlattenedInterfaceProperties(interfaceType)).filter(([_, prop]) => !isStruct(prop.sharedPropertyType.type));
+  if (allProperties.length !== Object.entries(getFlattenedInterfaceProperties(interfaceType)).length) {
     consola.consola.info(`Some properties on ${interfaceType.apiName} were skipped in the create action because they are structs`);
   }
   return defineAction({
@@ -1860,8 +1933,8 @@ 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) {
+  const allProperties = Object.entries(getFlattenedInterfaceProperties(interfaceType)).filter(([_, prop]) => !isStruct(prop.sharedPropertyType.type));
+  if (allProperties.length !== Object.entries(getFlattenedInterfaceProperties(interfaceType)).length) {
     consola.consola.info(`Some properties on ${interfaceType.apiName} were skipped in the modify action because they are structs`);
   }
   return defineAction({
@@ -2131,6 +2204,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 +2294,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 +2323,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 +2340,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 +2569,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 +2669,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 +2686,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 +2764,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 +2805,7 @@ function getLinkMeta(meta) {
     displayName,
     description
   } = meta;
-  const apiNameWithNamespace = sanitize(namespace, apiName);
+  const apiNameWithNamespace = combineApiNamespaceIfMissing(namespace, apiName);
   const apiNameWithoutNamespace = withoutNamespace(apiNameWithNamespace);
   return {
     apiName: apiNameWithNamespace,
@@ -2801,7 +2855,7 @@ 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 +2951,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 +3000,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;