@osdk/maker 0.14.0-beta.1 → 0.14.0-beta.10

package/build/cjs/index.cjs

@@ -3,12 +3,13 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var consola = require('consola');
-var fs2 = require('fs/promises');
-var path2 = require('path');
-var invariant6 = require('tiny-invariant');
+var fs3 = require('fs/promises');
+var path3 = require('path');
+var invariant7 = require('tiny-invariant');
 var yargs = require('yargs');
 var helpers = require('yargs/helpers');
-var fs = require('fs');
+var fs2 = require('fs');
+var typescriptSdkDocs = require('@osdk/typescript-sdk-docs');
 var crypto = require('crypto');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -31,11 +32,11 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var fs2__namespace = /*#__PURE__*/_interopNamespace(fs2);
-var path2__namespace = /*#__PURE__*/_interopNamespace(path2);
-var invariant6__default = /*#__PURE__*/_interopDefault(invariant6);
+var fs3__namespace = /*#__PURE__*/_interopNamespace(fs3);
+var path3__namespace = /*#__PURE__*/_interopNamespace(path3);
+var invariant7__default = /*#__PURE__*/_interopDefault(invariant7);
 var yargs__default = /*#__PURE__*/_interopDefault(yargs);
-var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var fs2__namespace = /*#__PURE__*/_interopNamespace(fs2);
 
 // src/cli/main.ts
 
@@ -66,6 +67,193 @@ var OntologyEntityTypeEnum = /* @__PURE__ */ (function(OntologyEntityTypeEnum2)
   return OntologyEntityTypeEnum2;
 })({});
 
+// src/conversion/toMarketplace/convertCardinality.ts
+function convertCardinality(cardinality) {
+  if (cardinality === "OneToMany" || cardinality === void 0) {
+    return "ONE_TO_MANY";
+  }
+  return "ONE_TO_ONE";
+}
+
+// src/conversion/toMarketplace/convertLink.ts
+function convertLink(linkType) {
+  validateLink(linkType);
+  let definition;
+  let datasource = void 0;
+  if ("one" in linkType) {
+    const {
+      apiName: oneObjectApiName,
+      object: oneObject
+    } = getObject(linkType.one.object);
+    const {
+      apiName: toManyObjectApiName} = getObject(linkType.toMany.object);
+    definition = {
+      type: "oneToMany",
+      oneToMany: {
+        cardinalityHint: convertCardinality(linkType.cardinality),
+        manyToOneLinkMetadata: linkType.toMany.metadata,
+        objectTypeRidManySide: toManyObjectApiName,
+        objectTypeRidOneSide: oneObjectApiName,
+        oneToManyLinkMetadata: linkType.one.metadata,
+        oneSidePrimaryKeyToManySidePropertyMapping: [{
+          from: {
+            apiName: oneObject.primaryKeyPropertyApiName,
+            object: oneObjectApiName
+          },
+          to: {
+            apiName: linkType.manyForeignKeyProperty,
+            object: toManyObjectApiName
+          }
+        }]
+      }
+    };
+  } else if ("intermediaryObjectType" in linkType) {
+    const {
+      apiName: manyObjectApiName} = getObject(linkType.many.object);
+    const {
+      apiName: toManyObjectApiName} = getObject(linkType.toMany.object);
+    definition = {
+      type: "intermediary",
+      intermediary: {
+        objectTypeAToBLinkMetadata: linkType.many.metadata,
+        objectTypeBToALinkMetadata: linkType.toMany.metadata,
+        objectTypeRidA: manyObjectApiName,
+        objectTypeRidB: toManyObjectApiName,
+        intermediaryObjectTypeRid: linkType.intermediaryObjectType.apiName,
+        aToIntermediaryLinkTypeRid: cleanAndValidateLinkTypeId(linkType.many.linkToIntermediary.apiName),
+        intermediaryToBLinkTypeRid: cleanAndValidateLinkTypeId(linkType.toMany.linkToIntermediary.apiName)
+      }
+    };
+  } else {
+    const {
+      apiName: manyObjectApiName,
+      object: manyObject
+    } = getObject(linkType.many.object);
+    const {
+      apiName: toManyObjectApiName,
+      object: toManyObject
+    } = getObject(linkType.toMany.object);
+    definition = {
+      type: "manyToMany",
+      manyToMany: {
+        objectTypeAToBLinkMetadata: linkType.many.metadata,
+        objectTypeBToALinkMetadata: linkType.toMany.metadata,
+        objectTypeRidA: manyObjectApiName,
+        objectTypeRidB: toManyObjectApiName,
+        peeringMetadata: void 0,
+        objectTypeAPrimaryKeyPropertyMapping: [{
+          from: {
+            apiName: manyObject.primaryKeyPropertyApiName,
+            object: manyObjectApiName
+          },
+          to: {
+            apiName: manyObject.primaryKeyPropertyApiName,
+            object: manyObjectApiName
+          }
+        }],
+        objectTypeBPrimaryKeyPropertyMapping: [{
+          from: {
+            apiName: toManyObject.primaryKeyPropertyApiName,
+            object: toManyObjectApiName
+          },
+          to: {
+            apiName: toManyObject.primaryKeyPropertyApiName,
+            object: toManyObjectApiName
+          }
+        }]
+      }
+    };
+    datasource = {
+      datasourceName: linkType.apiName,
+      datasource: {
+        type: "dataset",
+        dataset: {
+          datasetRid: "link-".concat(linkType.apiName),
+          writebackDatasetRid: void 0,
+          objectTypeAPrimaryKeyMapping: [{
+            property: {
+              apiName: manyObject.primaryKeyPropertyApiName,
+              object: manyObjectApiName
+            },
+            column: manyObject.primaryKeyPropertyApiName
+          }],
+          objectTypeBPrimaryKeyMapping: [{
+            property: {
+              apiName: toManyObject.primaryKeyPropertyApiName,
+              object: toManyObjectApiName
+            },
+            column: toManyObject.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
+    }
+  };
+}
+function validateLink(linkDefinition) {
+  if ("one" in linkDefinition) {
+    const {
+      object: oneObject
+    } = getObject(linkDefinition.one.object);
+    const {
+      apiName: toManyObjectApiName,
+      object: toManyObject
+    } = getObject(linkDefinition.toMany.object);
+    const foreignKey = toManyObject.properties?.find((p) => p.apiName === linkDefinition.manyForeignKeyProperty);
+    !(foreignKey !== void 0) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Foreign key ${linkDefinition.manyForeignKeyProperty} on link ${linkDefinition.apiName} does not exist on object ${toManyObjectApiName}`) : invariant7__default.default(false) : void 0;
+    !/([a-z][a-z0-9\\-]*)/.test(linkDefinition.apiName) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Top level link api names are expected to match the regex pattern ([a-z][a-z0-9\\-]*) ${linkDefinition.apiName} does not match`) : invariant7__default.default(false) : void 0;
+    const typesMatch = foreignKey.type === oneObject.properties?.find((p) => p.apiName === oneObject.primaryKeyPropertyApiName)?.type;
+    !typesMatch ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Link ${linkDefinition.apiName} has type mismatch between the one side's primary key and the foreign key on the many side`) : invariant7__default.default(false) : void 0;
+  }
+  if ("intermediaryObjectType" in linkDefinition) {
+    const {
+      apiName: intermediaryObjectTypeApiName} = getObject(linkDefinition.intermediaryObjectType);
+    const {
+      apiName: manyObjectApiName,
+      object: manyObject
+    } = getObject(linkDefinition.many.object);
+    const {
+      apiName: toManyObjectApiName} = getObject(linkDefinition.toMany.object);
+    const {
+      apiName: manyIntermediaryOneObjectApiName} = getObject(linkDefinition.many.linkToIntermediary.one.object);
+    const {
+      apiName: manyIntermediaryToManyObjectApiName} = getObject(linkDefinition.many.linkToIntermediary.toMany.object);
+    !("one" in linkDefinition.many.linkToIntermediary && manyIntermediaryOneObjectApiName === manyObject.apiName && manyIntermediaryToManyObjectApiName === intermediaryObjectTypeApiName) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `LinkTypeA ${linkDefinition.many.linkToIntermediary.apiName} must be a many to one link from intermediary object ${intermediaryObjectTypeApiName} to objectA ${manyObjectApiName}`) : invariant7__default.default(false) : void 0;
+    const {
+      apiName: toManyIntermediaryOneObjectApiName} = getObject(linkDefinition.toMany.linkToIntermediary.one.object);
+    const {
+      apiName: toManyIntermediaryToManyObjectApiName} = getObject(linkDefinition.toMany.linkToIntermediary.toMany.object);
+    !("one" in linkDefinition.toMany.linkToIntermediary && toManyIntermediaryOneObjectApiName === toManyObjectApiName && toManyIntermediaryToManyObjectApiName === intermediaryObjectTypeApiName) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `LinkTypeB ${linkDefinition.toMany.linkToIntermediary.apiName} must be a many to one link from intermediary object ${intermediaryObjectTypeApiName} to objectB ${toManyObjectApiName}`) : invariant7__default.default(false) : void 0;
+  }
+}
+function getObject(object) {
+  const objectApiName = typeof object === "string" ? object : object.apiName;
+  const fullObject = ontologyDefinition[OntologyEntityTypeEnum.OBJECT_TYPE][objectApiName];
+  !(fullObject !== void 0) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Object ${objectApiName} is not defined`) : invariant7__default.default(false) : void 0;
+  return {
+    apiName: objectApiName,
+    object: fullObject
+  };
+}
+
 // src/api/interface/getFlattenedInterfaceProperties.ts
 function getFlattenedInterfaceProperties(interfaceType) {
   let properties = interfaceType.propertiesV2;
@@ -107,12 +295,20 @@ function defineObject(objectDef) {
   if (ontologyDefinition[OntologyEntityTypeEnum.OBJECT_TYPE][apiName] !== void 0) {
     throw new Error(`Object type with apiName ${objectDef.apiName} is already defined`);
   }
-  !API_NAME_PATTERN.test(objectDef.apiName) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Invalid API name ${objectDef.apiName}. API names must match the regex ${API_NAME_PATTERN}.`) : invariant6__default.default(false) : void 0;
-  !propertyApiNames.includes(objectDef.titlePropertyApiName) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Title property ${objectDef.titlePropertyApiName} is not defined on object ${objectDef.apiName}`) : invariant6__default.default(false) : void 0;
-  !propertyApiNames.includes(objectDef.primaryKeyPropertyApiName) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Primary key property ${objectDef.primaryKeyPropertyApiName} does not exist on object ${objectDef.apiName}`) : invariant6__default.default(false) : void 0;
-  !!objectDef.properties?.[objectDef.primaryKeyPropertyApiName]?.editOnly ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Primary key property ${objectDef.primaryKeyPropertyApiName} on object ${objectDef.apiName} cannot be edit-only`) : invariant6__default.default(false) : void 0;
-  const retentionPeriod = objectDef.datasource?.retentionPeriod;
-  !(retentionPeriod === void 0 || ISO_8601_DURATION.test(retentionPeriod)) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Retention period "${retentionPeriod}" on object "${objectDef.apiName}" is not a valid ISO 8601 duration string`) : invariant6__default.default(false) : void 0;
+  !API_NAME_PATTERN.test(objectDef.apiName) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Invalid API name ${objectDef.apiName}. API names must match the regex ${API_NAME_PATTERN}.`) : invariant7__default.default(false) : void 0;
+  !propertyApiNames.includes(objectDef.titlePropertyApiName) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Title property ${objectDef.titlePropertyApiName} is not defined on object ${objectDef.apiName}`) : invariant7__default.default(false) : void 0;
+  !propertyApiNames.includes(objectDef.primaryKeyPropertyApiName) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Primary key property ${objectDef.primaryKeyPropertyApiName} does not exist on object ${objectDef.apiName}`) : invariant7__default.default(false) : void 0;
+  !!objectDef.properties?.[objectDef.primaryKeyPropertyApiName]?.editOnly ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Primary key property ${objectDef.primaryKeyPropertyApiName} on object ${objectDef.apiName} cannot be edit-only`) : invariant7__default.default(false) : void 0;
+  const retentionPeriods = (objectDef.datasources ?? []).filter((ds) => ds.type === "stream").map((ds) => ds.retentionPeriod);
+  retentionPeriods.forEach((retentionPeriod) => {
+    !(retentionPeriod === void 0 || ISO_8601_DURATION.test(retentionPeriod)) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Retention period "${retentionPeriod}" on object "${objectDef.apiName}" is not a valid ISO 8601 duration string`) : invariant7__default.default(false) : void 0;
+  });
+  const baseDatasources = (objectDef.datasources ?? []).filter((ds) => ["dataset", "stream", "restrictedView"].includes(ds.type));
+  !(baseDatasources.length <= 1) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Object ${objectDef.apiName} has more than one base datasource (got: [${baseDatasources.map((ds) => ds.type).join(", ")}])`) : invariant7__default.default(false) : void 0;
+  const derivedDatasources = (objectDef.datasources ?? []).filter((ds) => ds.type === "derived");
+  if (derivedDatasources.length > 0) {
+    derivedDatasources.forEach((ds) => validateDerivedDatasource(objectDef, ds));
+  }
   if (objectDef.status === "experimental") {
     const activeProperties = [];
     Object.entries(objectDef.properties ?? {}).forEach(([apiName2, property]) => {
@@ -120,14 +316,14 @@ function defineObject(objectDef) {
         activeProperties.push(apiName2);
       }
     });
-    !(activeProperties.length === 0) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `When object "${objectDef.apiName}" has experimental status, no properties can have "active" status, but found active properties: ${activeProperties.join(", ")}`) : invariant6__default.default(false) : void 0;
+    !(activeProperties.length === 0) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `When object "${objectDef.apiName}" has experimental status, no properties can have "active" status, but found active properties: ${activeProperties.join(", ")}`) : invariant7__default.default(false) : void 0;
   }
   if (objectDef.status && typeof objectDef.status === "object" && objectDef.status.type === "deprecated") {
     const deadline = objectDef.status.deadline;
-    !(deadline !== void 0 && ISO_8601_DATETIME.test(deadline)) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Deprecated status deadline "${deadline}" on object "${objectDef.apiName}" is not a valid ISO 8601 datetime string`) : invariant6__default.default(false) : void 0;
+    !(deadline !== void 0 && ISO_8601_DATETIME.test(deadline)) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Deprecated status deadline "${deadline}" on object "${objectDef.apiName}" is not a valid ISO 8601 datetime string`) : invariant7__default.default(false) : void 0;
   }
-  !!isExotic(objectDef.properties?.[objectDef.titlePropertyApiName]?.type) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Title property ${objectDef.titlePropertyApiName} must be a primitive type`) : invariant6__default.default(false) : void 0;
-  !!isExotic(objectDef.properties?.[objectDef.primaryKeyPropertyApiName]?.type) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Primary key property ${objectDef.primaryKeyPropertyApiName} can only be primitive types`) : invariant6__default.default(false) : void 0;
+  !!isExotic(objectDef.properties?.[objectDef.titlePropertyApiName]?.type) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Title property ${objectDef.titlePropertyApiName} must be a primitive type`) : invariant7__default.default(false) : void 0;
+  !!isExotic(objectDef.properties?.[objectDef.primaryKeyPropertyApiName]?.type) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Primary key property ${objectDef.primaryKeyPropertyApiName} can only be primitive types`) : invariant7__default.default(false) : void 0;
   objectDef.implementsInterfaces?.forEach((interfaceImpl) => {
     const allInterfaceProperties = getFlattenedInterfaceProperties(interfaceImpl.implements);
     const nonExistentInterfaceProperties = interfaceImpl.propertyMapping.map((val) => val.interfaceProperty).filter((interfaceProperty) => allInterfaceProperties[addNamespaceIfNone(interfaceProperty)] === void 0).map((interfaceProp) => ({
@@ -146,7 +342,7 @@ function defineObject(objectDef) {
     };
     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" ? invariant6__default.default(false, "\n" + allFailedValidations.map(formatValidationErrors).join("\n")) : invariant6__default.default(false) : void 0;
+    !(allFailedValidations.length === 0) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, "\n" + allFailedValidations.map(formatValidationErrors).join("\n")) : invariant7__default.default(false) : void 0;
   });
   const flattenedProperties = Object.entries(objectDef.properties ?? {}).map(([apiName2, property]) => convertUserObjectPropertyType(property.apiName ?? apiName2, property));
   const finalObject = {
@@ -197,6 +393,72 @@ function convertUserObjectPropertyType(apiName, property) {
     type: property.type
   };
 }
+function validateDerivedDatasource(objectDef, datasource) {
+  !(datasource.linkDefinition.length > 0) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Derived datasource for object '${objectDef.apiName}' must have at least one link.`) : invariant7__default.default(false) : void 0;
+  datasource.linkDefinition.forEach((link) => {
+    const linkApiName = link.linkType.apiName;
+    !(ontologyDefinition[OntologyEntityTypeEnum.LINK_TYPE][linkApiName] !== void 0 || importedTypes[OntologyEntityTypeEnum.LINK_TYPE][linkApiName] !== void 0) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Link type '${linkApiName}' used in derived datasource for object '${objectDef.apiName}' is not defined.`) : invariant7__default.default(false) : void 0;
+  });
+  Object.keys(datasource.propertyMapping).forEach((prop) => {
+    !(objectDef.properties?.[prop] !== void 0) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Property '${prop}' used in derived datasource for object '${objectDef.apiName}' is not defined.`) : invariant7__default.default(false) : void 0;
+  });
+  const isLinkedProperties = typeof Object.values(datasource.propertyMapping)[0] === "string";
+  if (isLinkedProperties) {
+    validateLinkedProperties(datasource);
+  } else {
+    validateAggregations(datasource, objectDef);
+  }
+}
+function validateLinkedProperties(datasource, objectDef) {
+  const foreignProperties = Object.values(datasource.propertyMapping);
+  const finalObject = getObject(datasource.linkDefinition.at(-1).linkType.toMany.object).object;
+  foreignProperties.forEach((prop) => {
+    !(finalObject.properties?.find((p) => p.apiName === prop) !== void 0) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Property '${prop}' on object '${finalObject.apiName}' is not defined`) : invariant7__default.default(false) : void 0;
+  });
+}
+function validateAggregations(datasource, objectDef) {
+  const props = datasource.propertyMapping;
+  Object.entries(props).forEach(([propName, agg]) => {
+    const property = objectDef.properties[propName];
+    switch (agg.type) {
+      case "collectList":
+      case "collectSet":
+        !isCollectible(property) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Property '${propName}' on object '${objectDef.apiName}' is not collectible`) : invariant7__default.default(false) : void 0;
+        !(agg.limit <= 100) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `[Error] Limit for collection '${propName}' on object '${objectDef.apiName}' is greater than 100`) : invariant7__default.default(false) : void 0;
+        break;
+      case "avg":
+      case "sum":
+        !isNumeric(property.type) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Property '${propName}' on object '${objectDef.apiName}' is not numeric`) : invariant7__default.default(false) : void 0;
+        break;
+      case "min":
+      case "max":
+      case "approximateCardinality":
+      case "exactCardinality":
+        !isPrimitive(property.type) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Property '${propName}' on object '${objectDef.apiName}' is not primitive`) : invariant7__default.default(false) : void 0;
+        break;
+    }
+    if (agg.type !== "count") {
+      const foreignProperty = agg.property;
+      const finalObject = getObject(datasource.linkDefinition.at(-1).linkType.toMany.object).object;
+      !(finalObject.properties?.find((p) => p.apiName === foreignProperty) !== void 0) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Property '${foreignProperty}' on object '${finalObject.apiName}' is not defined`) : invariant7__default.default(false) : void 0;
+    }
+  });
+}
+function isCollectible(property) {
+  if (!(property.array ?? false)) {
+    return false;
+  }
+  const typeType = typeof property.type === "string" ? property.type : property.type.type;
+  return ["boolean", "byte", "date", "double", "float", "geohash", "geoshape", "integer", "long", "mediareference", "short", "string", "struct", "timestamp"].includes(typeType);
+}
+function isNumeric(type) {
+  const typeType = typeof type === "string" ? type : type.type;
+  return ["byte", "double", "float", "integer", "long", "short"].includes(typeType);
+}
+function isPrimitive(type) {
+  const typeType = typeof type === "string" ? type : type.type;
+  return ["boolean", "byte", "date", "double", "float", "integer", "long", "short", "string", "timestamp"].includes(typeType);
+}
 
 // src/conversion/toMarketplace/convertActionSections.ts
 function convertActionSections(action) {
@@ -224,14 +486,14 @@ function convertActionSections(action) {
     }
   }]));
 }
-function convertConditionDefinition(condition, objectProperties) {
+function convertConditionDefinition(condition, actionParameters) {
   switch (condition.type) {
     case "and":
       if ("conditions" in condition) {
         return {
           type: "and",
           and: {
-            conditions: condition.conditions.map((c) => convertConditionDefinition(c, objectProperties))
+            conditions: condition.conditions.map((c) => convertConditionDefinition(c, actionParameters))
           }
         };
       } else {
@@ -242,7 +504,7 @@ function convertConditionDefinition(condition, objectProperties) {
         return {
           type: "or",
           or: {
-            conditions: condition.conditions.map((c) => convertConditionDefinition(c, objectProperties))
+            conditions: condition.conditions.map((c) => convertConditionDefinition(c, actionParameters))
           }
         };
       } else {
@@ -278,7 +540,7 @@ function convertConditionDefinition(condition, objectProperties) {
         }
       };
     case "parameter":
-      !objectProperties?.includes(condition.parameterId) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Action parameter condition references unknown parameter ${condition.parameterId}`) : invariant6__default.default(false) : void 0;
+      !actionParameters?.some((param) => param.id === condition.parameterId) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Action parameter condition references unknown parameter ${condition.parameterId}`) : invariant7__default.default(false) : void 0;
       return {
         type: "comparison",
         comparison: {
@@ -296,7 +558,7 @@ function convertConditionDefinition(condition, objectProperties) {
 }
 
 // src/conversion/toMarketplace/convertActionParameterConditionalOverride.ts
-function convertActionParameterConditionalOverride(override, validation, objectProperties) {
+function convertActionParameterConditionalOverride(override, validation, actionParameters) {
   let parameterBlockOverride;
   switch (override.type) {
     case "required":
@@ -361,7 +623,7 @@ function convertActionParameterConditionalOverride(override, validation, objectP
       throw new Error(`Unknown parameter override type`);
   }
   return {
-    condition: convertConditionDefinition(override.condition, objectProperties),
+    condition: convertConditionDefinition(override.condition, actionParameters),
     parameterBlockOverrides: [parameterBlockOverride]
   };
 }
@@ -393,9 +655,9 @@ function convertActionVisibility(visibility) {
 }
 
 // src/conversion/toMarketplace/convertSectionConditionalOverride.ts
-function convertSectionConditionalOverride(override, defaultVisibility, objectProperties) {
+function convertSectionConditionalOverride(override, defaultVisibility, actionParameters) {
   return {
-    condition: convertConditionDefinition(override.condition, objectProperties),
+    condition: convertConditionDefinition(override.condition, actionParameters),
     sectionBlockOverrides: [{
       type: "visibility",
       visibility: {
@@ -441,7 +703,7 @@ function convertActionValidation(action) {
             required: convertParameterRequirementConstraint(p.validation.required)
           }
         },
-        conditionalOverrides: p.validation.conditionalOverrides?.map((override) => convertActionParameterConditionalOverride(override, p.validation, getActionTypeObjectParameters(action))) ?? []
+        conditionalOverrides: p.validation.conditionalOverrides?.map((override) => convertActionParameterConditionalOverride(override, p.validation, action.parameters)) ?? []
       }];
     })),
     sectionValidations: {
@@ -457,7 +719,7 @@ function convertActionValidation(action) {
             visible: {}
           }
         },
-        conditionalOverrides: section.conditionalOverrides?.map((override) => convertSectionConditionalOverride(override, section.defaultVisibility ?? "visible", getActionTypeObjectParameters(action))) ?? []
+        conditionalOverrides: section.conditionalOverrides?.map((override) => convertSectionConditionalOverride(override, section.defaultVisibility ?? "visible", action.parameters)) ?? []
       }]))
     }
   };
@@ -484,20 +746,6 @@ function convertParameterRequirementConstraint(required) {
     }
   };
 }
-function getActionTypeObjectParameters(actionType) {
-  switch (actionType.rules[0].type) {
-    case "addObjectRule":
-      return Object.keys(actionType.rules[0].addObjectRule.propertyValues);
-    case "modifyObjectRule":
-      return Object.keys(actionType.rules[0].modifyObjectRule.propertyValues);
-    case "addOrModifyObjectRuleV2":
-      return Object.keys(actionType.rules[0].addOrModifyObjectRuleV2.propertyValues);
-    case "deleteObjectRule":
-      return [];
-    default:
-      return void 0;
-  }
-}
 function convertNullabilityToDataConstraint(prop) {
   if (typeof prop.type === "object" && prop.type.type === "marking") {
     if (prop.nullability === void 0) {
@@ -510,7 +758,7 @@ function convertNullabilityToDataConstraint(prop) {
         }
       };
     }
-    !prop.nullability?.noNulls ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, "Marking property type has noNulls set to false, marking properties must not be nullable") : invariant6__default.default(false) : void 0;
+    !prop.nullability?.noNulls ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, "Marking property type has noNulls set to false, marking properties must not be nullable") : invariant7__default.default(false) : void 0;
     return {
       propertyTypeConstraints: [],
       nullability: void 0,
@@ -714,134 +962,12 @@ function convertInterface(interfaceType) {
   };
 }
 
-// src/conversion/toMarketplace/convertCardinality.ts
-function convertCardinality(cardinality) {
-  if (cardinality === "OneToMany" || cardinality === void 0) {
-    return "ONE_TO_MANY";
-  }
-  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
-          }]
-        }
-      },
-      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
-    }
-  };
-}
-
 // src/conversion/toMarketplace/convertDatasourceDefinition.ts
 function convertDatasourceDefinition(objectType, properties) {
-  switch (objectType.datasource?.type) {
+  const baseDatasource = objectType.datasources?.find((ds) => ["dataset", "stream", "restrictedView"].includes(ds.type));
+  switch (baseDatasource?.type) {
     case "stream":
-      const window = objectType.datasource.retentionPeriod;
+      const window = baseDatasource.retentionPeriod;
       const retentionPolicy = window ? {
         type: "time",
         time: {
@@ -1030,7 +1156,7 @@ function convertValueTypeDataConstraints(dataConstraints) {
 // src/conversion/toMarketplace/convertObjectPropertyType.ts
 function convertObjectPropertyType(property) {
   const apiName = namespace + property.apiName;
-  !(!shouldNotHaveRenderHints(property.type) || !hasRenderHints(property.typeClasses)) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Property type ${apiName} of type '${getPropertyTypeName(property.type)}' should not have render hints`) : invariant6__default.default(false) : void 0;
+  !(!shouldNotHaveRenderHints(property.type) || !hasRenderHints(property.typeClasses)) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Property type ${apiName} of type '${getPropertyTypeName(property.type)}' should not have render hints`) : invariant7__default.default(false) : void 0;
   const output = {
     apiName: property.apiName,
     sharedPropertyTypeApiName: property.sharedPropertyType?.apiName,
@@ -1060,12 +1186,16 @@ function convertObjectPropertyType(property) {
 
 // src/conversion/toMarketplace/convertObject.ts
 function convertObject(objectType) {
-  const propertyDatasources = (objectType.properties ?? []).flatMap((prop) => extractPropertyDatasource(prop, objectType.apiName));
+  const {
+    derivedDatasources,
+    derivedPropertyNames
+  } = extractDerivedDatasources(objectType);
+  const propertyDatasources = (objectType.properties ?? []).filter((prop) => !derivedPropertyNames.includes(prop.apiName)).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 objectDatasource = buildDatasource(objectType.apiName, convertDatasourceDefinition(objectType, (objectType.properties ?? []).filter((prop) => !derivedPropertyNames.includes(prop.apiName))), classificationInputGroup, mandatoryInputGroup);
   const implementations = objectType.implementsInterfaces ?? [];
   return {
     objectType: {
@@ -1099,7 +1229,7 @@ function convertObject(objectType) {
       })),
       allImplementsInterfaces: {}
     },
-    datasources: [...propertyDatasources, objectDatasource],
+    datasources: [...propertyDatasources, ...derivedDatasources, objectDatasource],
     entityMetadata: {
       arePatchesEnabled: objectType.editsEnabled ?? false
     }
@@ -1142,6 +1272,80 @@ function extractPropertyDatasource(property, objectTypeApiName) {
       return [];
   }
 }
+function extractDerivedDatasources(objectType) {
+  const inputDerivedDatasources = (objectType.datasources ?? []).filter((ds) => ds.type === "derived");
+  const derivedDatasources = inputDerivedDatasources.map((ds, i) => buildDerivedDatasource(ds, i, objectType.apiName));
+  const derivedPropertyNames = inputDerivedDatasources.flatMap((ds) => Object.keys(ds.propertyMapping));
+  return {
+    derivedDatasources,
+    derivedPropertyNames
+  };
+}
+function buildDerivedDatasource(datasource, index, objectTypeApiName) {
+  const linkDefinition = {
+    type: "multiHopLink",
+    multiHopLink: {
+      steps: datasource.linkDefinition.map((step) => ({
+        type: "searchAround",
+        searchAround: {
+          linkTypeIdentifier: {
+            type: "linkType",
+            linkType: cleanAndValidateLinkTypeId(step.linkType.apiName)
+          },
+          linkTypeSide: step.side ?? "SOURCE"
+        }
+      }))
+    }
+  };
+  const isLinkedProperties = typeof Object.values(datasource.propertyMapping)[0] === "string";
+  const derivedDefinition = isLinkedProperties ? {
+    type: "linkedProperties",
+    linkedProperties: {
+      linkDefinition,
+      propertyTypeMapping: Object.fromEntries(Object.entries(datasource.propertyMapping).map(([sourceProp, targetProp]) => [sourceProp, {
+        type: "propertyType",
+        propertyType: targetProp
+      }]))
+    }
+  } : {
+    type: "aggregatedProperties",
+    aggregatedProperties: {
+      linkDefinition,
+      propertyTypeMapping: Object.fromEntries(Object.entries(datasource.propertyMapping).map(([sourceProp, agg]) => [sourceProp, buildAggregation(agg)]))
+    }
+  };
+  const fullDefinition = {
+    type: "derived",
+    derived: {
+      definition: derivedDefinition
+    }
+  };
+  return buildDatasource(objectTypeApiName + ".derived." + index.toString(), fullDefinition);
+}
+function buildAggregation(agg) {
+  const type = agg.type;
+  const limit = "limit" in agg ? agg.limit : void 0;
+  const foreignProperty = "property" in agg ? agg.property : void 0;
+  const innerDef = {};
+  if (type !== "count") {
+    if (["collectList", "collectSet"].includes(type)) {
+      innerDef["linkedProperty"] = {
+        type: "propertyType",
+        propertyType: foreignProperty
+      };
+      innerDef["limit"] = limit;
+    } else {
+      innerDef["property"] = {
+        type: "propertyType",
+        propertyType: foreignProperty
+      };
+    }
+  }
+  return {
+    type,
+    [type]: innerDef
+  };
+}
 
 // src/conversion/toMarketplace/convertOntologyDefinitionToWireBlockData.ts
 function convertOntologyDefinitionToWireBlockData(ontology) {
@@ -1240,8 +1444,543 @@ function getFormContentOrdering(action, parameterOrdering) {
   return formContentOrdering;
 }
 
-// src/api/defineOntology.ts
-var ontologyDefinition;
+// ../../node_modules/.pnpm/mustache@4.2.0/node_modules/mustache/mustache.mjs
+var objectToString = Object.prototype.toString;
+var isArray = Array.isArray || function isArrayPolyfill(object) {
+  return objectToString.call(object) === "[object Array]";
+};
+function isFunction(object) {
+  return typeof object === "function";
+}
+function typeStr(obj) {
+  return isArray(obj) ? "array" : typeof obj;
+}
+function escapeRegExp(string) {
+  return string.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&");
+}
+function hasProperty(obj, propName) {
+  return obj != null && typeof obj === "object" && propName in obj;
+}
+function primitiveHasOwnProperty(primitive, propName) {
+  return primitive != null && typeof primitive !== "object" && primitive.hasOwnProperty && primitive.hasOwnProperty(propName);
+}
+var regExpTest = RegExp.prototype.test;
+function testRegExp(re, string) {
+  return regExpTest.call(re, string);
+}
+var nonSpaceRe = /\S/;
+function isWhitespace(string) {
+  return !testRegExp(nonSpaceRe, string);
+}
+var entityMap = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;",
+  "/": "&#x2F;",
+  "`": "&#x60;",
+  "=": "&#x3D;"
+};
+function escapeHtml(string) {
+  return String(string).replace(/[&<>"'`=\/]/g, function fromEntityMap(s) {
+    return entityMap[s];
+  });
+}
+var whiteRe = /\s*/;
+var spaceRe = /\s+/;
+var equalsRe = /\s*=/;
+var curlyRe = /\s*\}/;
+var tagRe = /#|\^|\/|>|\{|&|=|!/;
+function parseTemplate(template, tags) {
+  if (!template) return [];
+  var lineHasNonSpace = false;
+  var sections = [];
+  var tokens = [];
+  var spaces = [];
+  var hasTag = false;
+  var nonSpace = false;
+  var indentation = "";
+  var tagIndex = 0;
+  function stripSpace() {
+    if (hasTag && !nonSpace) {
+      while (spaces.length) delete tokens[spaces.pop()];
+    } else {
+      spaces = [];
+    }
+    hasTag = false;
+    nonSpace = false;
+  }
+  var openingTagRe, closingTagRe, closingCurlyRe;
+  function compileTags(tagsToCompile) {
+    if (typeof tagsToCompile === "string") tagsToCompile = tagsToCompile.split(spaceRe, 2);
+    if (!isArray(tagsToCompile) || tagsToCompile.length !== 2) throw new Error("Invalid tags: " + tagsToCompile);
+    openingTagRe = new RegExp(escapeRegExp(tagsToCompile[0]) + "\\s*");
+    closingTagRe = new RegExp("\\s*" + escapeRegExp(tagsToCompile[1]));
+    closingCurlyRe = new RegExp("\\s*" + escapeRegExp("}" + tagsToCompile[1]));
+  }
+  compileTags(tags || mustache.tags);
+  var scanner = new Scanner(template);
+  var start, type, value, chr, token, openSection;
+  while (!scanner.eos()) {
+    start = scanner.pos;
+    value = scanner.scanUntil(openingTagRe);
+    if (value) {
+      for (var i = 0, valueLength = value.length; i < valueLength; ++i) {
+        chr = value.charAt(i);
+        if (isWhitespace(chr)) {
+          spaces.push(tokens.length);
+          indentation += chr;
+        } else {
+          nonSpace = true;
+          lineHasNonSpace = true;
+          indentation += " ";
+        }
+        tokens.push(["text", chr, start, start + 1]);
+        start += 1;
+        if (chr === "\n") {
+          stripSpace();
+          indentation = "";
+          tagIndex = 0;
+          lineHasNonSpace = false;
+        }
+      }
+    }
+    if (!scanner.scan(openingTagRe)) break;
+    hasTag = true;
+    type = scanner.scan(tagRe) || "name";
+    scanner.scan(whiteRe);
+    if (type === "=") {
+      value = scanner.scanUntil(equalsRe);
+      scanner.scan(equalsRe);
+      scanner.scanUntil(closingTagRe);
+    } else if (type === "{") {
+      value = scanner.scanUntil(closingCurlyRe);
+      scanner.scan(curlyRe);
+      scanner.scanUntil(closingTagRe);
+      type = "&";
+    } else {
+      value = scanner.scanUntil(closingTagRe);
+    }
+    if (!scanner.scan(closingTagRe)) throw new Error("Unclosed tag at " + scanner.pos);
+    if (type == ">") {
+      token = [type, value, start, scanner.pos, indentation, tagIndex, lineHasNonSpace];
+    } else {
+      token = [type, value, start, scanner.pos];
+    }
+    tagIndex++;
+    tokens.push(token);
+    if (type === "#" || type === "^") {
+      sections.push(token);
+    } else if (type === "/") {
+      openSection = sections.pop();
+      if (!openSection) throw new Error('Unopened section "' + value + '" at ' + start);
+      if (openSection[1] !== value) throw new Error('Unclosed section "' + openSection[1] + '" at ' + start);
+    } else if (type === "name" || type === "{" || type === "&") {
+      nonSpace = true;
+    } else if (type === "=") {
+      compileTags(value);
+    }
+  }
+  stripSpace();
+  openSection = sections.pop();
+  if (openSection) throw new Error('Unclosed section "' + openSection[1] + '" at ' + scanner.pos);
+  return nestTokens(squashTokens(tokens));
+}
+function squashTokens(tokens) {
+  var squashedTokens = [];
+  var token, lastToken;
+  for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) {
+    token = tokens[i];
+    if (token) {
+      if (token[0] === "text" && lastToken && lastToken[0] === "text") {
+        lastToken[1] += token[1];
+        lastToken[3] = token[3];
+      } else {
+        squashedTokens.push(token);
+        lastToken = token;
+      }
+    }
+  }
+  return squashedTokens;
+}
+function nestTokens(tokens) {
+  var nestedTokens = [];
+  var collector = nestedTokens;
+  var sections = [];
+  var token, section;
+  for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) {
+    token = tokens[i];
+    switch (token[0]) {
+      case "#":
+      case "^":
+        collector.push(token);
+        sections.push(token);
+        collector = token[4] = [];
+        break;
+      case "/":
+        section = sections.pop();
+        section[5] = token[2];
+        collector = sections.length > 0 ? sections[sections.length - 1][4] : nestedTokens;
+        break;
+      default:
+        collector.push(token);
+    }
+  }
+  return nestedTokens;
+}
+function Scanner(string) {
+  this.string = string;
+  this.tail = string;
+  this.pos = 0;
+}
+Scanner.prototype.eos = function eos() {
+  return this.tail === "";
+};
+Scanner.prototype.scan = function scan(re) {
+  var match = this.tail.match(re);
+  if (!match || match.index !== 0) return "";
+  var string = match[0];
+  this.tail = this.tail.substring(string.length);
+  this.pos += string.length;
+  return string;
+};
+Scanner.prototype.scanUntil = function scanUntil(re) {
+  var index = this.tail.search(re), match;
+  switch (index) {
+    case -1:
+      match = this.tail;
+      this.tail = "";
+      break;
+    case 0:
+      match = "";
+      break;
+    default:
+      match = this.tail.substring(0, index);
+      this.tail = this.tail.substring(index);
+  }
+  this.pos += match.length;
+  return match;
+};
+function Context(view, parentContext) {
+  this.view = view;
+  this.cache = {
+    ".": this.view
+  };
+  this.parent = parentContext;
+}
+Context.prototype.push = function push(view) {
+  return new Context(view, this);
+};
+Context.prototype.lookup = function lookup(name) {
+  var cache = this.cache;
+  var value;
+  if (cache.hasOwnProperty(name)) {
+    value = cache[name];
+  } else {
+    var context = this, intermediateValue, names, index, lookupHit = false;
+    while (context) {
+      if (name.indexOf(".") > 0) {
+        intermediateValue = context.view;
+        names = name.split(".");
+        index = 0;
+        while (intermediateValue != null && index < names.length) {
+          if (index === names.length - 1) lookupHit = hasProperty(intermediateValue, names[index]) || primitiveHasOwnProperty(intermediateValue, names[index]);
+          intermediateValue = intermediateValue[names[index++]];
+        }
+      } else {
+        intermediateValue = context.view[name];
+        lookupHit = hasProperty(context.view, name);
+      }
+      if (lookupHit) {
+        value = intermediateValue;
+        break;
+      }
+      context = context.parent;
+    }
+    cache[name] = value;
+  }
+  if (isFunction(value)) value = value.call(this.view);
+  return value;
+};
+function Writer() {
+  this.templateCache = {
+    _cache: {},
+    set: function set(key, value) {
+      this._cache[key] = value;
+    },
+    get: function get(key) {
+      return this._cache[key];
+    },
+    clear: function clear() {
+      this._cache = {};
+    }
+  };
+}
+Writer.prototype.clearCache = function clearCache() {
+  if (typeof this.templateCache !== "undefined") {
+    this.templateCache.clear();
+  }
+};
+Writer.prototype.parse = function parse(template, tags) {
+  var cache = this.templateCache;
+  var cacheKey = template + ":" + (tags || mustache.tags).join(":");
+  var isCacheEnabled = typeof cache !== "undefined";
+  var tokens = isCacheEnabled ? cache.get(cacheKey) : void 0;
+  if (tokens == void 0) {
+    tokens = parseTemplate(template, tags);
+    isCacheEnabled && cache.set(cacheKey, tokens);
+  }
+  return tokens;
+};
+Writer.prototype.render = function render(template, view, partials, config) {
+  var tags = this.getConfigTags(config);
+  var tokens = this.parse(template, tags);
+  var context = view instanceof Context ? view : new Context(view, void 0);
+  return this.renderTokens(tokens, context, partials, template, config);
+};
+Writer.prototype.renderTokens = function renderTokens(tokens, context, partials, originalTemplate, config) {
+  var buffer = "";
+  var token, symbol, value;
+  for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) {
+    value = void 0;
+    token = tokens[i];
+    symbol = token[0];
+    if (symbol === "#") value = this.renderSection(token, context, partials, originalTemplate, config);
+    else if (symbol === "^") value = this.renderInverted(token, context, partials, originalTemplate, config);
+    else if (symbol === ">") value = this.renderPartial(token, context, partials, config);
+    else if (symbol === "&") value = this.unescapedValue(token, context);
+    else if (symbol === "name") value = this.escapedValue(token, context, config);
+    else if (symbol === "text") value = this.rawValue(token);
+    if (value !== void 0) buffer += value;
+  }
+  return buffer;
+};
+Writer.prototype.renderSection = function renderSection(token, context, partials, originalTemplate, config) {
+  var self = this;
+  var buffer = "";
+  var value = context.lookup(token[1]);
+  function subRender(template) {
+    return self.render(template, context, partials, config);
+  }
+  if (!value) return;
+  if (isArray(value)) {
+    for (var j = 0, valueLength = value.length; j < valueLength; ++j) {
+      buffer += this.renderTokens(token[4], context.push(value[j]), partials, originalTemplate, config);
+    }
+  } else if (typeof value === "object" || typeof value === "string" || typeof value === "number") {
+    buffer += this.renderTokens(token[4], context.push(value), partials, originalTemplate, config);
+  } else if (isFunction(value)) {
+    if (typeof originalTemplate !== "string") throw new Error("Cannot use higher-order sections without the original template");
+    value = value.call(context.view, originalTemplate.slice(token[3], token[5]), subRender);
+    if (value != null) buffer += value;
+  } else {
+    buffer += this.renderTokens(token[4], context, partials, originalTemplate, config);
+  }
+  return buffer;
+};
+Writer.prototype.renderInverted = function renderInverted(token, context, partials, originalTemplate, config) {
+  var value = context.lookup(token[1]);
+  if (!value || isArray(value) && value.length === 0) return this.renderTokens(token[4], context, partials, originalTemplate, config);
+};
+Writer.prototype.indentPartial = function indentPartial(partial, indentation, lineHasNonSpace) {
+  var filteredIndentation = indentation.replace(/[^ \t]/g, "");
+  var partialByNl = partial.split("\n");
+  for (var i = 0; i < partialByNl.length; i++) {
+    if (partialByNl[i].length && (i > 0 || !lineHasNonSpace)) {
+      partialByNl[i] = filteredIndentation + partialByNl[i];
+    }
+  }
+  return partialByNl.join("\n");
+};
+Writer.prototype.renderPartial = function renderPartial(token, context, partials, config) {
+  if (!partials) return;
+  var tags = this.getConfigTags(config);
+  var value = isFunction(partials) ? partials(token[1]) : partials[token[1]];
+  if (value != null) {
+    var lineHasNonSpace = token[6];
+    var tagIndex = token[5];
+    var indentation = token[4];
+    var indentedValue = value;
+    if (tagIndex == 0 && indentation) {
+      indentedValue = this.indentPartial(value, indentation, lineHasNonSpace);
+    }
+    var tokens = this.parse(indentedValue, tags);
+    return this.renderTokens(tokens, context, partials, indentedValue, config);
+  }
+};
+Writer.prototype.unescapedValue = function unescapedValue(token, context) {
+  var value = context.lookup(token[1]);
+  if (value != null) return value;
+};
+Writer.prototype.escapedValue = function escapedValue(token, context, config) {
+  var escape = this.getConfigEscape(config) || mustache.escape;
+  var value = context.lookup(token[1]);
+  if (value != null) return typeof value === "number" && escape === mustache.escape ? String(value) : escape(value);
+};
+Writer.prototype.rawValue = function rawValue(token) {
+  return token[1];
+};
+Writer.prototype.getConfigTags = function getConfigTags(config) {
+  if (isArray(config)) {
+    return config;
+  } else if (config && typeof config === "object") {
+    return config.tags;
+  } else {
+    return void 0;
+  }
+};
+Writer.prototype.getConfigEscape = function getConfigEscape(config) {
+  if (config && typeof config === "object" && !isArray(config)) {
+    return config.escape;
+  } else {
+    return void 0;
+  }
+};
+var mustache = {
+  name: "mustache.js",
+  version: "4.2.0",
+  tags: ["{{", "}}"],
+  clearCache: void 0,
+  escape: void 0,
+  parse: void 0,
+  render: void 0,
+  Scanner: void 0,
+  Context: void 0,
+  Writer: void 0,
+  /**
+   * Allows a user to override the default caching strategy, by providing an
+   * object with set, get and clear methods. This can also be used to disable
+   * the cache by setting it to the literal `undefined`.
+   */
+  set templateCache(cache) {
+    defaultWriter.templateCache = cache;
+  },
+  /**
+   * Gets the default or overridden caching object from the default writer.
+   */
+  get templateCache() {
+    return defaultWriter.templateCache;
+  }
+};
+var defaultWriter = new Writer();
+mustache.clearCache = function clearCache2() {
+  return defaultWriter.clearCache();
+};
+mustache.parse = function parse2(template, tags) {
+  return defaultWriter.parse(template, tags);
+};
+mustache.render = function render2(template, view, partials, config) {
+  if (typeof template !== "string") {
+    throw new TypeError('Invalid template! Template should be a "string" but "' + typeStr(template) + '" was given as the first argument for mustache#render(template, view, partials)');
+  }
+  return defaultWriter.render(template, view, partials, config);
+};
+mustache.escape = escapeHtml;
+mustache.Scanner = Scanner;
+mustache.Context = Context;
+mustache.Writer = Writer;
+var mustache_default = mustache;
+
+// src/api/code-snippets/snippetTypes.ts
+var interfaceSnippets = /* @__PURE__ */ (function(interfaceSnippets2) {
+  interfaceSnippets2[interfaceSnippets2["loadInterfacesReference"] = 0] = "loadInterfacesReference";
+  interfaceSnippets2[interfaceSnippets2["loadAllInterfacesReference"] = 1] = "loadAllInterfacesReference";
+  interfaceSnippets2[interfaceSnippets2["loadOrderedInterfacesReference"] = 2] = "loadOrderedInterfacesReference";
+  interfaceSnippets2[interfaceSnippets2["searchInterfacesReference"] = 3] = "searchInterfacesReference";
+  interfaceSnippets2[interfaceSnippets2["loadInterfaceMetadataSnippet"] = 4] = "loadInterfaceMetadataSnippet";
+  interfaceSnippets2[interfaceSnippets2["subscribeToObjectSetInstructions"] = 5] = "subscribeToObjectSetInstructions";
+  return interfaceSnippets2;
+})({});
+var actionSnippets = /* @__PURE__ */ (function(actionSnippets2) {
+  actionSnippets2[actionSnippets2["applyAction"] = 0] = "applyAction";
+  actionSnippets2[actionSnippets2["batchApplyAction"] = 1] = "batchApplyAction";
+  return actionSnippets2;
+})({});
+var objectSnippets = /* @__PURE__ */ (function(objectSnippets2) {
+  objectSnippets2[objectSnippets2["loadSingleObjectGuide"] = 0] = "loadSingleObjectGuide";
+  objectSnippets2[objectSnippets2["loadObjectsReference"] = 1] = "loadObjectsReference";
+  objectSnippets2[objectSnippets2["loadAllObjectsReference"] = 2] = "loadAllObjectsReference";
+  objectSnippets2[objectSnippets2["loadOrderedInterfacesReference"] = 3] = "loadOrderedInterfacesReference";
+  objectSnippets2[objectSnippets2["searchObjectsGuide"] = 4] = "searchObjectsGuide";
+  objectSnippets2[objectSnippets2["aggregationTemplate"] = 5] = "aggregationTemplate";
+  objectSnippets2[objectSnippets2["objectSetOperationsGuide"] = 6] = "objectSetOperationsGuide";
+  objectSnippets2[objectSnippets2["loadObjectMetadataSnippet"] = 7] = "loadObjectMetadataSnippet";
+  objectSnippets2[objectSnippets2["subscribeToObjectSetInstructions"] = 8] = "subscribeToObjectSetInstructions";
+  return objectSnippets2;
+})({});
+
+// src/api/code-snippets/createCodeSnippets.ts
+function createCodeSnippets(ontology, packageName, outputDir) {
+  if (outputDir === void 0) {
+    outputDir = "./code-snippets";
+  }
+  if (!fs2__namespace.existsSync(outputDir)) {
+    fs2__namespace.mkdirSync(outputDir, {
+      recursive: true
+    });
+  }
+  if (packageName === void 0) {
+    packageName = "";
+  }
+  consola.consola.info("Generating code snippets to ", outputDir);
+  for (const type of Object.values(OntologyEntityTypeEnum)) {
+    for (const object of Object.values(ontology[type])) {
+      let snippet = {};
+      switch (type) {
+        case OntologyEntityTypeEnum.OBJECT_TYPE:
+          snippet = generateObjectSnippet(object, packageName);
+          break;
+        case OntologyEntityTypeEnum.ACTION_TYPE:
+          snippet = generateActionSnippet(object, packageName);
+          break;
+        case OntologyEntityTypeEnum.INTERFACE_TYPE:
+          snippet = generateInterfaceSnippet(object, packageName);
+          break;
+        default:
+          continue;
+      }
+      fs2__namespace.writeFileSync(path3__namespace.join(outputDir, object.apiName), JSON.stringify(snippet));
+    }
+  }
+  consola.consola.info("Finished Code Snippet Generation");
+}
+function generateInterfaceSnippet(interfaceType, packageName) {
+  const interfaceContext = {
+    "interfaceApiName": interfaceType.apiName,
+    "packageName": packageName,
+    "objectOrInterfaceApiName": interfaceType.apiName,
+    "propertyNames": Object.keys(interfaceType.propertiesV2)
+  };
+  return getSnippets(interfaceSnippets, interfaceContext);
+}
+function generateObjectSnippet(objectType, packageName) {
+  const objectContext = {
+    "objectType": objectType.apiName,
+    "packageName": packageName,
+    "objectOrInterfaceApiName": objectType.apiName
+  };
+  return getSnippets(objectSnippets, objectContext);
+}
+function generateActionSnippet(actionType, packageName) {
+  const actionContext = {
+    "actionApiName": actionType.apiName,
+    "packageName": packageName
+  };
+  return getSnippets(actionSnippets, actionContext);
+}
+function getSnippets(snippetType, context) {
+  const allSnippets = {};
+  for (const templateName of Object.keys(snippetType).filter((key) => isNaN(Number(key)))) {
+    const latestTemplate = Object.values(typescriptSdkDocs.TYPESCRIPT_OSDK_SNIPPETS.versions).find((v) => v.snippets[templateName])?.snippets[templateName][0].template ?? "";
+    const renderedTemplate = mustache_default.render(latestTemplate, context);
+    allSnippets[templateName] = renderedTemplate;
+  }
+  return allSnippets;
+}
+
+// src/api/defineOntology.ts
+var ontologyDefinition;
 var importedTypes;
 var dependencies;
 var namespace;
@@ -1255,7 +1994,7 @@ function updateOntology(entity) {
   }
   ontologyDefinition[OntologyEntityTypeEnum.VALUE_TYPE][entity.apiName].push(entity);
 }
-async function defineOntology(ns, body, outputDir, dependencyFile, randomnessKey) {
+async function defineOntology(ns, body, outputDir, dependencyFile, codeSnippetFiles, snippetPackageName, snippetFileOutputDir, randomnessKey) {
   namespace = ns;
   dependencies = {};
   ontologyDefinition = {
@@ -1286,10 +2025,13 @@ async function defineOntology(ns, body, outputDir, dependencyFile, randomnessKey
   if (dependencyFile) {
     writeDependencyFile(dependencyFile);
   }
+  if (codeSnippetFiles) {
+    createCodeSnippets(ontologyDefinition, snippetPackageName, snippetFileOutputDir);
+  }
   return convertOntologyDefinition(ontologyDefinition, randomnessKey);
 }
 function writeStaticObjects(outputDir) {
-  const codegenDir = path2__namespace.resolve(outputDir, "codegen");
+  const codegenDir = path3__namespace.resolve(outputDir, "codegen");
   const typeDirs = {
     [OntologyEntityTypeEnum.SHARED_PROPERTY_TYPE]: "shared-property-types",
     [OntologyEntityTypeEnum.ACTION_TYPE]: "action-types",
@@ -1298,31 +2040,31 @@ function writeStaticObjects(outputDir) {
     [OntologyEntityTypeEnum.INTERFACE_TYPE]: "interface-types",
     [OntologyEntityTypeEnum.VALUE_TYPE]: "value-types"
   };
-  if (!fs__namespace.existsSync(codegenDir)) {
-    fs__namespace.mkdirSync(codegenDir, {
+  if (!fs2__namespace.existsSync(codegenDir)) {
+    fs2__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, {
+    const currentTypeDirPath = path3__namespace.join(codegenDir, typeDirNameFromMap);
+    if (fs2__namespace.existsSync(currentTypeDirPath)) {
+      fs2__namespace.rmSync(currentTypeDirPath, {
         recursive: true,
         force: true
       });
     }
-    fs__namespace.mkdirSync(currentTypeDirPath, {
+    fs2__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 typeDirPath = path3__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 filePath = path3__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 = `
@@ -1334,7 +2076,7 @@ const ${entityFileNameBase}_base: ${entityTypeName} = ${ontologyTypeEnumKey ===
         
 export const ${entityFileNameBase}: ${entityTypeName} = wrapWithProxy(${entityFileNameBase}_base);
         `;
-      fs__namespace.writeFileSync(filePath, content, {
+      fs2__namespace.writeFileSync(filePath, content, {
         flag: "w"
       });
       entityModuleNames.push(entityFileNameBase);
@@ -1345,8 +2087,8 @@ export const ${entityFileNameBase}: ${entityTypeName} = wrapWithProxy(${entityFi
   });
   if (topLevelExportStatements.length > 0) {
     const mainIndexContent = dependencyInjectionString() + topLevelExportStatements.join("\n") + "\n";
-    const mainIndexFilePath = path2__namespace.join(outputDir, "index.ts");
-    fs__namespace.writeFileSync(mainIndexFilePath, mainIndexContent, {
+    const mainIndexFilePath = path3__namespace.join(outputDir, "index.ts");
+    fs2__namespace.writeFileSync(mainIndexFilePath, mainIndexContent, {
       flag: "w"
     });
   }
@@ -1702,7 +2444,7 @@ function getEntityTypeName(type) {
   }[type];
 }
 function writeDependencyFile(dependencyFile) {
-  fs__namespace.writeFileSync(dependencyFile, JSON.stringify(dependencies, null, 2));
+  fs2__namespace.writeFileSync(dependencyFile, JSON.stringify(dependencies, null, 2));
 }
 function dependencyInjectionString() {
   const namespaceNoDot = namespace.endsWith(".") ? namespace.slice(0, -1) : namespace;
@@ -1719,20 +2461,20 @@ function addNamespaceIfNone(apiName) {
 var apiNamespaceRegex = /^[a-z0-9-]+(\.[a-z0-9-]+)*\.$/;
 var uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 async function main(args = process.argv) {
-  const commandLineOpts = await yargs__default.default(helpers.hideBin(args)).version("0.14.0-beta.1").wrap(Math.min(150, yargs__default.default().terminalWidth())).strict().help().options({
+  const commandLineOpts = await yargs__default.default(helpers.hideBin(args)).version("0.14.0-beta.10").wrap(Math.min(150, yargs__default.default().terminalWidth())).strict().help().options({
     input: {
       alias: "i",
       describe: "Input file",
       type: "string",
       default: ".ontology/ontology.ts",
-      coerce: path2__namespace.resolve
+      coerce: path3__namespace.resolve
     },
     output: {
       alias: "o",
       describe: "Output file",
       type: "string",
       default: "ontology.json",
-      coerce: path2__namespace.resolve
+      coerce: path3__namespace.resolve
     },
     apiNamespace: {
       describe: "Api name prefix for namespaced ontology types",
@@ -1744,95 +2486,91 @@ async function main(args = process.argv) {
       describe: "Snapshot directory",
       type: "string",
       default: "snapshots",
-      coerce: path2__namespace.resolve
+      coerce: path3__namespace.resolve
     },
     outputDir: {
       alias: "d",
       describe: "Directory for generated ontology entities",
       type: "string",
-      coerce: path2__namespace.resolve
+      coerce: path3__namespace.resolve
     },
     valueTypesOutput: {
       describe: "Value Type Output File",
       type: "string",
       default: "value-types.json",
-      coerce: path2__namespace.resolve
+      coerce: path3__namespace.resolve
     },
     dependencies: {
       describe: "File to write dependencies to",
       type: "string",
-      coerce: path2__namespace.resolve
+      coerce: path3__namespace.resolve
+    },
+    generateCodeSnippets: {
+      describe: "Enable code snippet files creation",
+      type: "boolean",
+      default: false
+    },
+    codeSnippetPackageName: {
+      describe: "The package name that will be displayed in the code snippets",
+      default: "",
+      type: "string"
+    },
+    codeSnippetDir: {
+      describe: "Directory for generated code snippet files",
+      type: "string",
+      default: "./",
+      coerce: path3__namespace.resolve
     },
     randomnessKey: {
       describe: "Value used to assure uniqueness of entities",
       type: "string",
-      coerce: path2__namespace.resolve
+      coerce: path3__namespace.resolve
     }
   }).parseAsync();
   let apiNamespace = "";
   if (commandLineOpts.apiNamespace.length !== 0) {
     apiNamespace = commandLineOpts.apiNamespace.slice(-1) !== "." ? commandLineOpts.apiNamespace + "." : commandLineOpts.apiNamespace;
-    !(apiNamespace.length < 1024) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, "API namespace is too long.") : invariant6__default.default(false) : void 0;
-    !apiNamespaceRegex.test(apiNamespace) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, "API namespace is invalid! It is expected to conform to ^[a-z0-9-]+(.[a-z0-9-]+)*.$") : invariant6__default.default(false) : void 0;
+    !(apiNamespace.length < 1024) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, "API namespace is too long.") : invariant7__default.default(false) : void 0;
+    !apiNamespaceRegex.test(apiNamespace) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, "API namespace is invalid! It is expected to conform to ^[a-z0-9-]+(.[a-z0-9-]+)*.$") : invariant7__default.default(false) : void 0;
   }
   consola.consola.info(`Loading ontology from ${commandLineOpts.input}`);
+  if (!commandLineOpts.generateCodeSnippets && (commandLineOpts.codeSnippetPackageName !== "" || commandLineOpts.codeSnippetDir !== path3__namespace.resolve("./"))) {
+    consola.consola.info("Package name and/or directory supplied for code snippets, but code snippet generation is false.");
+  }
   if (commandLineOpts.randomnessKey !== void 0) {
-    !uuidRegex.test(commandLineOpts.randomnessKey) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, "Supplied randomness key is not a uuid and shouldn't be used as a uniqueness guarantee") : invariant6__default.default(false) : void 0;
+    !uuidRegex.test(commandLineOpts.randomnessKey) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, "Supplied randomness key is not a uuid and shouldn't be used as a uniqueness guarantee") : invariant7__default.default(false) : void 0;
   }
-  const ontologyIr = await loadOntology(commandLineOpts.input, apiNamespace, commandLineOpts.outputDir, commandLineOpts.dependencies, commandLineOpts.randomnessKey);
+  const ontologyIr = await loadOntology(commandLineOpts.input, apiNamespace, commandLineOpts.outputDir, commandLineOpts.dependencies, commandLineOpts.generateCodeSnippets, commandLineOpts.codeSnippetPackageName, commandLineOpts.codeSnippetDir, commandLineOpts.randomnessKey);
   consola.consola.info(`Saving ontology to ${commandLineOpts.output}`);
-  await fs2__namespace.writeFile(commandLineOpts.output, JSON.stringify(ontologyIr, null, 2));
+  await fs3__namespace.writeFile(commandLineOpts.output, JSON.stringify(ontologyIr, null, 2));
   if (ontologyIr.valueTypes.valueTypes.length > 0 || ontologyIr.importedValueTypes.valueTypes.length > 0) {
-    await fs2__namespace.writeFile(commandLineOpts.valueTypesOutput, JSON.stringify(ontologyIr.valueTypes, null, 2));
+    await fs3__namespace.writeFile(commandLineOpts.valueTypesOutput, JSON.stringify(ontologyIr.valueTypes, null, 2));
   }
 }
-async function loadOntology(input, apiNamespace, outputDir, dependencyFile, randomnessKey) {
-  const q = await defineOntology(apiNamespace, async () => await import(input), outputDir, dependencyFile, randomnessKey);
+async function loadOntology(input, apiNamespace, outputDir, dependencyFile, generateCodeSnippets, snippetPackageName, codeSnippetDir, randomnessKey) {
+  const q = await defineOntology(apiNamespace, async () => await import(input), outputDir, dependencyFile, generateCodeSnippets, snippetPackageName, codeSnippetDir, randomnessKey);
   return q;
 }
 var MAX_SEARCH_DEPTH = 5;
 function addDependency(namespaceNoDot, fileInPackage) {
-  let dir = path2__namespace.dirname(fileInPackage);
+  let dir = path3__namespace.dirname(fileInPackage);
   let packageJsonPath = null;
   for (let i = 0; i < MAX_SEARCH_DEPTH; i++) {
-    const candidate = path2__namespace.join(dir, "package.json");
-    if (fs__namespace.existsSync(candidate)) {
+    const candidate = path3__namespace.join(dir, "package.json");
+    if (fs2__namespace.existsSync(candidate)) {
       packageJsonPath = candidate;
       break;
     }
-    const parentDir = path2__namespace.dirname(dir);
+    const parentDir = path3__namespace.dirname(dir);
     if (parentDir === dir) break;
     dir = parentDir;
   }
   if (!packageJsonPath) {
     throw new Error(`Could not find a package.json within ${MAX_SEARCH_DEPTH} parent directories of ${fileInPackage}`);
   }
-  const packageJson = JSON.parse(fs__namespace.readFileSync(packageJsonPath, "utf-8"));
+  const packageJson = JSON.parse(fs2__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) {
@@ -1842,472 +2580,125 @@ function isActionParameterTypePrimitive(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`);
+var CREATE_INTERFACE_OBJECT_PARAMETER = "objectTypeParameter";
+var MODIFY_INTERFACE_OBJECT_PARAMETER = "interfaceObjectToModifyParameter";
+function defineAction(actionDef) {
+  const apiName = namespace + actionDef.apiName;
+  const parameterIds = (actionDef.parameters ?? []).map((p) => p.id);
+  if (ontologyDefinition[OntologyEntityTypeEnum.ACTION_TYPE][apiName] !== void 0) {
+    throw new Error(`Action type with apiName ${actionDef.apiName} is already defined`);
   }
-  return defineAction({
-    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: [def.interfaceType.apiName]
-        }
-      },
-      validation: {
-        required: true,
-        allowedValues: def.objectType === void 0 ? {
-          type: "objectTypeReference",
-          interfaceTypes: [def.interfaceType.apiName]
-        } : {
-          type: "oneOf",
-          oneOf: [{
-            label: def.objectType.displayName,
-            value: {
-              type: "objectType",
-              objectType: {
-                objectTypeId: def.objectType.apiName
-              }
-            }
-          }]
-        }
-      }
-    }, ...allProperties.map(([id, prop]) => ({
-      id,
-      displayName: prop.sharedPropertyType.displayName ?? prop.sharedPropertyType.nonNameSpacedApiName,
-      type: extractActionParameterType(prop.sharedPropertyType),
-      typeClasses: prop.sharedPropertyType.typeClasses ?? [],
-      validation: {
-        required: prop.sharedPropertyType.array ?? false ? {
-          listLength: {}
-        } : prop.required,
-        allowedValues: extractAllowedValuesFromPropertyType(prop.sharedPropertyType.type)
-      }
-    }))],
-    status: def.interfaceType.status.type !== "deprecated" ? def.interfaceType.status.type : def.interfaceType.status,
-    entities: {
-      affectedInterfaceTypes: [def.interfaceType.apiName],
+  !/^[a-z0-9]+(-[a-z0-9]+)*$/.test(actionDef.apiName) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Action type apiName "${actionDef.apiName}" must be alphanumeric, lowercase, and kebab-case`) : invariant7__default.default(false) : void 0;
+  const parameterIdsSet = new Set(parameterIds);
+  !(parameterIdsSet.size === parameterIds.length) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Parameter ids must be unique`) : invariant7__default.default(false) : void 0;
+  const parameterIdsNotFound = Array.from(referencedParameterIds(actionDef)).filter((p) => !parameterIdsSet.has(p));
+  !(parameterIdsNotFound.length === 0) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Parameters ${JSON.stringify(parameterIdsNotFound)} were referenced but not defined`) : invariant7__default.default(false) : void 0;
+  const definedSectionIds = new Set(Object.keys(actionDef.sections ?? []));
+  const undefinedSectionsInOrdering = (actionDef.formContentOrdering ?? []).flatMap((s) => s.type === "parameterId" ? [] : [s.sectionId]).filter((sId) => !definedSectionIds.has(sId));
+  !(undefinedSectionsInOrdering.length === 0) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Sections [${undefinedSectionsInOrdering}] were referenced in content ordering but not defined`) : invariant7__default.default(false) : void 0;
+  !(actionDef.rules.length > 0) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Action type ${actionDef.apiName} must have at least one logic rule`) : invariant7__default.default(false) : void 0;
+  actionDef.rules.forEach((rule) => {
+    if (rule.type === "modifyObjectRule") {
+      !parameterIds.some((id) => id === rule.modifyObjectRule.objectToModify) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Object to modify parameter must be defined in parameters`) : invariant7__default.default(false) : void 0;
+    }
+    if (rule.type === "deleteObjectRule") {
+      !parameterIds.some((id) => id === rule.deleteObjectRule.objectToDelete) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Object to delete parameter must be defined in parameters`) : invariant7__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" ? invariant7__default.default(false, `Interface object to modify parameter must be an interface reference`) : invariant7__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" ? invariant7__default.default(false, `Interface type ${interfaceReference} does not exist`) : invariant7__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" ? invariant7__default.default(false, `Shared property type ${spt} does not exist in interface type ${interfaceReference}`) : invariant7__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" ? invariant7__default.default(false, `Interface type ${rule.addInterfaceRule.interfaceApiName} does not exist`) : invariant7__default.default(false) : void 0;
+      Object.keys(rule.addInterfaceRule.sharedPropertyValues).forEach((spt) => {
+        !Object.keys(getFlattenedInterfaceProperties(interfaceType)).includes(spt) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Shared property type ${spt} does not exist in interface type ${interfaceType.apiName}`) : invariant7__default.default(false) : void 0;
+      });
+    }
+  });
+  const fullAction = {
+    ...actionDef,
+    apiName,
+    entities: actionDef.entities ?? {
+      affectedInterfaceTypes: [],
       affectedObjectTypes: [],
       affectedLinkTypes: [],
       typeGroups: []
     },
-    rules: [{
-      type: "addInterfaceRule",
-      addInterfaceRule: {
-        interfaceApiName: def.interfaceType.apiName,
-        objectTypeParameter: "objectTypeParameter",
-        sharedPropertyValues: Object.fromEntries(allProperties.map(([id, _prop]) => [id, {
-          type: "parameterId",
-          parameterId: id
-        }]))
-      }
-    }],
-    ...def.validation ? {
-      validation: convertValidationRule(def.validation)
-    } : {}
-  });
+    __type: OntologyEntityTypeEnum.ACTION_TYPE
+  };
+  validateActionConfiguration(fullAction);
+  updateOntology(fullAction);
+  return fullAction;
 }
-function defineCreateObjectAction(def) {
-  validateActionParameters(def);
-  const propertyParameters = Object.keys(def.objectType.properties ?? {}).filter((id) => !Object.keys(def.nonParameterMappings ?? {}).includes(id) && !def.excludedProperties?.includes(id) && !isStruct(def.objectType.properties?.[id].type));
-  const parameterNames = new Set(propertyParameters);
-  Object.keys(def.parameterConfiguration ?? {}).forEach((param) => parameterNames.add(param));
-  const actionApiName = def.apiName ?? `create-object-${kebab(def.objectType.apiName.split(".").pop() ?? def.objectType.apiName)}`;
-  if (def.parameterOrdering) {
-    validateParameterOrdering(def.parameterOrdering, parameterNames, actionApiName);
-  }
-  const parameters = createParameters(def, parameterNames);
-  const mappings = Object.fromEntries(Object.entries(def.nonParameterMappings ?? {}).map(([id, value]) => [id, convertMappingValue(value)]));
-  return defineAction({
-    apiName: actionApiName,
-    displayName: def.displayName ?? `Create ${def.objectType.displayName}`,
-    parameters,
-    status: def.status ?? "active",
-    entities: {
-      affectedInterfaceTypes: [],
-      affectedObjectTypes: [def.objectType.apiName],
-      affectedLinkTypes: [],
-      typeGroups: []
+function isPropertyParameter(def, name, type) {
+  return !Object.keys(def.nonParameterMappings ?? {}).includes(name) && !isStruct(type) && !def.excludedProperties?.includes(name);
+}
+function createParameters(def, propertyMap, parameterSet, requiredMap) {
+  const targetParams = getTargetParameters(def, parameterSet);
+  return [...targetParams, ...Array.from(parameterSet).map((id) => ({
+    id,
+    displayName: def.parameterConfiguration?.[id]?.displayName ?? propertyMap[id]?.displayName ?? uppercaseFirstLetter(id),
+    type: def.parameterConfiguration?.[id]?.customParameterType ?? extractActionParameterType(propertyMap[id]),
+    validation: def.parameterConfiguration?.[id] !== void 0 ? {
+      ...def.parameterConfiguration?.[id],
+      allowedValues: def.parameterConfiguration?.[id].allowedValues ?? (def.parameterConfiguration?.[id].customParameterType ? extractAllowedValuesFromActionParameterType(def.parameterConfiguration?.[id].customParameterType) : extractAllowedValuesFromPropertyType(propertyMap[id]?.type)),
+      required: def.parameterConfiguration?.[id].required ?? propertyMap[id]?.nullability?.noNulls ?? false
+    } : {
+      required: propertyMap[id]?.array ?? false ? {
+        listLength: propertyMap[id]?.nullability?.noEmptyCollections ? {
+          min: 1
+        } : {}
+      } : requiredMap?.[id] ?? propertyMap[id]?.nullability?.noNulls ?? false,
+      allowedValues: extractAllowedValuesFromPropertyType(propertyMap[id]?.type)
     },
-    rules: [{
-      type: "addObjectRule",
-      addObjectRule: {
-        objectTypeId: def.objectType.apiName,
-        propertyValues: {
-          ...Object.fromEntries(propertyParameters.map((p) => [p, {
-            type: "parameterId",
-            parameterId: p
-          }])),
-          ...mappings
+    defaultValue: def.parameterConfiguration?.[id]?.defaultValue,
+    description: def.parameterConfiguration?.[id]?.description
+  }))];
+}
+function getTargetParameters(def, parameterSet) {
+  const targetParams = [];
+  parameterSet.forEach((name) => {
+    if (name === MODIFY_OBJECT_PARAMETER) {
+      targetParams.push({
+        id: MODIFY_OBJECT_PARAMETER,
+        displayName: def.parameterConfiguration?.[name]?.displayName ?? "Modify object",
+        type: {
+          type: "objectReference",
+          objectReference: {
+            objectTypeId: def.objectType.apiName
+          }
         },
-        structFieldValues: {}
-      }
-    }],
-    parameterOrdering: def.parameterOrdering ?? createDefaultParameterOrdering(def, parameters),
-    ...def.actionLevelValidation ? {
-      validation: convertValidationRule(def.actionLevelValidation, Object.keys(def.objectType.properties ?? {}))
-    } : {},
-    ...def.defaultFormat && {
-      defaultFormat: def.defaultFormat
-    },
-    ...def.enableLayoutSwitch && {
-      enableLayoutSwitch: def.enableLayoutSwitch
-    },
-    ...def.displayAndFormat && {
-      displayAndFormat: def.displayAndFormat
-    },
-    ...def.sections && {
-      sections: Object.fromEntries(def.sections.map((section) => [section.id, section]))
-    },
-    ...def.submissionMetadata && {
-      submissionMetadata: def.submissionMetadata
-    }
-  });
-}
-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(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: def.interfaceType.apiName
-        }
-      },
-      validation: {
-        required: true,
-        allowedValues: def.objectType === void 0 ? {
-          type: "interfaceObjectQuery"
-        } : {
-          type: "oneOf",
-          oneOf: [{
-            label: def.objectType.displayName,
-            value: {
-              type: "objectType",
-              objectType: {
-                objectTypeId: def.objectType.apiName
-              }
-            }
-          }]
-        }
-      }
-    }, ...allProperties.map(([id, prop]) => ({
-      id,
-      displayName: prop.sharedPropertyType.displayName ?? prop.sharedPropertyType.nonNameSpacedApiName,
-      type: extractActionParameterType(prop.sharedPropertyType),
-      typeClasses: prop.sharedPropertyType.typeClasses ?? [],
-      validation: {
-        required: prop.sharedPropertyType.array ?? false ? {
-          listLength: {}
-        } : prop.required,
-        allowedValues: extractAllowedValuesFromPropertyType(prop.sharedPropertyType.type)
-      }
-    }))],
-    status: def.interfaceType.status.type !== "deprecated" ? def.interfaceType.status.type : def.interfaceType.status,
-    entities: {
-      affectedInterfaceTypes: [def.interfaceType.apiName],
-      affectedObjectTypes: [],
-      affectedLinkTypes: [],
-      typeGroups: []
-    },
-    rules: [{
-      type: "modifyInterfaceRule",
-      modifyInterfaceRule: {
-        interfaceObjectToModifyParameter: "interfaceObjectToModifyParameter",
-        sharedPropertyValues: Object.fromEntries(allProperties.map(([id, _prop]) => [id, {
-          type: "parameterId",
-          parameterId: id
-        }]))
-      }
-    }],
-    ...def.validation ? {
-      validation: convertValidationRule(def.validation)
-    } : {}
-  });
-}
-function defineModifyObjectAction(def) {
-  validateActionParameters(def);
-  const propertyParameters = Object.keys(def.objectType.properties ?? {}).filter((id) => !Object.keys(def.nonParameterMappings ?? {}).includes(id) && !def.excludedProperties?.includes(id) && !isStruct(def.objectType.properties?.[id].type) && id !== def.objectType.primaryKeyPropertyApiName);
-  const parameterNames = new Set(propertyParameters);
-  Object.keys(def.parameterConfiguration ?? {}).forEach((param) => parameterNames.add(param));
-  parameterNames.add(MODIFY_OBJECT_PARAMETER);
-  const actionApiName = def.apiName ?? `modify-object-${kebab(def.objectType.apiName.split(".").pop() ?? def.objectType.apiName)}`;
-  if (def.parameterOrdering) {
-    if (!def.parameterOrdering.includes(MODIFY_OBJECT_PARAMETER)) {
-      def.parameterOrdering = [MODIFY_OBJECT_PARAMETER, ...def.parameterOrdering];
-    }
-    validateParameterOrdering(def.parameterOrdering, parameterNames, actionApiName);
-  }
-  const parameters = createParameters(def, parameterNames);
-  parameters.forEach((p) => {
-    if (p.id !== MODIFY_OBJECT_PARAMETER && p.defaultValue === void 0) {
-      p.defaultValue = {
-        type: "objectParameterPropertyValue",
-        objectParameterPropertyValue: {
-          parameterId: MODIFY_OBJECT_PARAMETER,
-          propertyTypeId: p.id
-        }
-      };
-    }
-  });
-  const mappings = Object.fromEntries(Object.entries(def.nonParameterMappings ?? {}).map(([id, value]) => [id, convertMappingValue(value)]));
-  return defineAction({
-    apiName: actionApiName,
-    displayName: def.displayName ?? `Modify ${def.objectType.displayName}`,
-    parameters,
-    status: def.status ?? "active",
-    rules: [{
-      type: "modifyObjectRule",
-      modifyObjectRule: {
-        objectToModify: MODIFY_OBJECT_PARAMETER,
-        propertyValues: {
-          ...Object.fromEntries(propertyParameters.map((p) => [p, {
-            type: "parameterId",
-            parameterId: p
-          }])),
-          ...mappings
-        },
-        structFieldValues: {}
-      }
-    }],
-    entities: {
-      affectedInterfaceTypes: [],
-      affectedObjectTypes: [def.objectType.apiName],
-      affectedLinkTypes: [],
-      typeGroups: []
-    },
-    parameterOrdering: def.parameterOrdering ?? createDefaultParameterOrdering(def, parameters, MODIFY_OBJECT_PARAMETER),
-    ...def.actionLevelValidation ? {
-      validation: convertValidationRule(def.actionLevelValidation, Object.keys(def.objectType.properties ?? {}))
-    } : {},
-    ...def.defaultFormat && {
-      defaultFormat: def.defaultFormat
-    },
-    ...def.enableLayoutSwitch && {
-      enableLayoutSwitch: def.enableLayoutSwitch
-    },
-    ...def.displayAndFormat && {
-      displayAndFormat: def.displayAndFormat
-    },
-    ...def.sections && {
-      sections: Object.fromEntries(def.sections.map((section) => [section.id, section]))
-    },
-    ...def.submissionMetadata && {
-      submissionMetadata: def.submissionMetadata
-    }
-  });
-}
-function defineDeleteObjectAction(def) {
-  return defineAction({
-    apiName: def.apiName ?? `delete-object-${kebab(def.objectType.apiName.split(".").pop() ?? def.objectType.apiName)}`,
-    displayName: def.displayName ?? `Delete ${def.objectType.displayName}`,
-    parameters: [{
-      id: "objectToDeleteParameter",
-      displayName: "Delete object",
-      type: {
-        type: "objectReference",
-        objectReference: {
-          objectTypeId: def.objectType.apiName
-        }
-      },
-      validation: {
-        required: true,
-        allowedValues: {
-          type: "objectQuery"
-        }
-      }
-    }],
-    status: def.status ?? "active",
-    rules: [{
-      type: "deleteObjectRule",
-      deleteObjectRule: {
-        objectToDelete: "objectToDeleteParameter"
-      }
-    }],
-    entities: {
-      affectedInterfaceTypes: [],
-      affectedObjectTypes: [def.objectType.apiName],
-      affectedLinkTypes: [],
-      typeGroups: []
-    },
-    ...def.actionLevelValidation ? {
-      validation: convertValidationRule(def.actionLevelValidation, Object.keys(def.objectType.properties ?? {}))
-    } : {}
-  });
-}
-function defineCreateOrModifyObjectAction(def) {
-  validateActionParameters(def);
-  const propertyParameters = Object.keys(def.objectType.properties ?? {}).filter((id) => !Object.keys(def.nonParameterMappings ?? {}).includes(id) && !def.excludedProperties?.includes(id) && !isStruct(def.objectType.properties?.[id].type) && id !== def.objectType.primaryKeyPropertyApiName);
-  const parameterNames = new Set(propertyParameters);
-  Object.keys(def.parameterConfiguration ?? {}).forEach((param) => parameterNames.add(param));
-  parameterNames.add(CREATE_OR_MODIFY_OBJECT_PARAMETER);
-  const actionApiName = def.apiName ?? `create-or-modify-${kebab(def.objectType.apiName.split(".").pop() ?? def.objectType.apiName)}`;
-  if (def.parameterOrdering) {
-    if (!def.parameterOrdering.includes(CREATE_OR_MODIFY_OBJECT_PARAMETER)) {
-      def.parameterOrdering = [CREATE_OR_MODIFY_OBJECT_PARAMETER, ...def.parameterOrdering];
-    }
-    validateParameterOrdering(def.parameterOrdering, parameterNames, actionApiName);
-  }
-  const parameters = createParameters(def, parameterNames);
-  parameters.forEach((p) => {
-    if (p.id !== CREATE_OR_MODIFY_OBJECT_PARAMETER && p.defaultValue === void 0) {
-      p.defaultValue = {
-        type: "objectParameterPropertyValue",
-        objectParameterPropertyValue: {
-          parameterId: CREATE_OR_MODIFY_OBJECT_PARAMETER,
-          propertyTypeId: p.id
-        }
-      };
-    }
-  });
-  const mappings = Object.fromEntries(Object.entries(def.nonParameterMappings ?? {}).map(([id, value]) => [id, convertMappingValue(value)]));
-  return defineAction({
-    apiName: actionApiName,
-    displayName: def.displayName ?? `Create or Modify ${def.objectType.displayName}`,
-    parameters,
-    status: def.status ?? "active",
-    rules: [{
-      type: "addOrModifyObjectRuleV2",
-      addOrModifyObjectRuleV2: {
-        objectToModify: CREATE_OR_MODIFY_OBJECT_PARAMETER,
-        propertyValues: {
-          ...Object.fromEntries(propertyParameters.map((p) => [p, {
-            type: "parameterId",
-            parameterId: p
-          }])),
-          ...mappings
-        },
-        structFieldValues: {}
-      }
-    }],
-    entities: {
-      affectedInterfaceTypes: [],
-      affectedObjectTypes: [def.objectType.apiName],
-      affectedLinkTypes: [],
-      typeGroups: []
-    },
-    parameterOrdering: def.parameterOrdering ?? createDefaultParameterOrdering(def, parameters, CREATE_OR_MODIFY_OBJECT_PARAMETER),
-    ...def.actionLevelValidation ? {
-      validation: convertValidationRule(def.actionLevelValidation, Object.keys(def.objectType.properties ?? {}))
-    } : {},
-    ...def.defaultFormat && {
-      defaultFormat: def.defaultFormat
-    },
-    ...def.enableLayoutSwitch && {
-      enableLayoutSwitch: def.enableLayoutSwitch
-    },
-    ...def.displayAndFormat && {
-      displayAndFormat: def.displayAndFormat
-    },
-    ...def.sections && {
-      sections: Object.fromEntries(def.sections.map((section) => [section.id, section]))
-    },
-    ...def.submissionMetadata && {
-      submissionMetadata: def.submissionMetadata
-    }
-  });
-}
-function defineAction(actionDef) {
-  const apiName = namespace + actionDef.apiName;
-  const parameterIds = (actionDef.parameters ?? []).map((p) => p.id);
-  if (ontologyDefinition[OntologyEntityTypeEnum.ACTION_TYPE][apiName] !== void 0) {
-    throw new Error(`Action type with apiName ${actionDef.apiName} is already defined`);
-  }
-  !/^[a-z0-9]+(-[a-z0-9]+)*$/.test(actionDef.apiName) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Action type apiName "${actionDef.apiName}" must be alphanumeric, lowercase, and kebab-case`) : invariant6__default.default(false) : void 0;
-  const parameterIdsSet = new Set(parameterIds);
-  !(parameterIdsSet.size === parameterIds.length) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Parameter ids must be unique`) : invariant6__default.default(false) : void 0;
-  const parameterIdsNotFound = Array.from(referencedParameterIds(actionDef)).filter((p) => !parameterIdsSet.has(p));
-  !(parameterIdsNotFound.length === 0) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Parameters ${JSON.stringify(parameterIdsNotFound)} were referenced but not defined`) : invariant6__default.default(false) : void 0;
-  const definedSectionIds = new Set(Object.keys(actionDef.sections ?? []));
-  const undefinedSectionsInOrdering = (actionDef.formContentOrdering ?? []).flatMap((s) => s.type === "parameterId" ? [] : [s.sectionId]).filter((sId) => !definedSectionIds.has(sId));
-  !(undefinedSectionsInOrdering.length === 0) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Sections [${undefinedSectionsInOrdering}] were referenced in content ordering but not defined`) : invariant6__default.default(false) : void 0;
-  !(actionDef.rules.length > 0) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Action type ${actionDef.apiName} must have at least one logic rule`) : invariant6__default.default(false) : void 0;
-  actionDef.rules.forEach((rule) => {
-    if (rule.type === "modifyObjectRule") {
-      !parameterIds.some((id) => id === rule.modifyObjectRule.objectToModify) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Object to modify parameter must be defined in parameters`) : invariant6__default.default(false) : void 0;
-    }
-    if (rule.type === "deleteObjectRule") {
-      !parameterIds.some((id) => id === rule.deleteObjectRule.objectToDelete) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Object to delete parameter must be defined in parameters`) : invariant6__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" ? invariant6__default.default(false, `Interface object to modify parameter must be an interface reference`) : invariant6__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" ? invariant6__default.default(false, `Interface type ${interfaceReference} does not exist`) : invariant6__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" ? invariant6__default.default(false, `Shared property type ${spt} does not exist in interface type ${interfaceReference}`) : invariant6__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" ? invariant6__default.default(false, `Interface type ${rule.addInterfaceRule.interfaceApiName} does not exist`) : invariant6__default.default(false) : void 0;
-      Object.keys(rule.addInterfaceRule.sharedPropertyValues).forEach((spt) => {
-        !Object.keys(getFlattenedInterfaceProperties(interfaceType)).includes(spt) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Shared property type ${spt} does not exist in interface type ${interfaceType.apiName}`) : invariant6__default.default(false) : void 0;
-      });
-    }
-  });
-  const fullAction = {
-    ...actionDef,
-    apiName,
-    entities: actionDef.entities ?? {
-      affectedInterfaceTypes: [],
-      affectedObjectTypes: [],
-      affectedLinkTypes: [],
-      typeGroups: []
-    },
-    __type: OntologyEntityTypeEnum.ACTION_TYPE
-  };
-  validateActionConfiguration(fullAction);
-  updateOntology(fullAction);
-  return fullAction;
-}
-function createParameters(def, parameterSet) {
-  const targetParam = [];
-  parameterSet.forEach((name) => {
-    if (name === MODIFY_OBJECT_PARAMETER) {
-      targetParam.push({
-        id: MODIFY_OBJECT_PARAMETER,
-        displayName: def.parameterConfiguration?.[name]?.displayName ?? "Modify object",
-        type: {
-          type: "objectReference",
-          objectReference: {
-            objectTypeId: def.objectType.apiName
-          }
-        },
-        validation: {
-          ...def.parameterConfiguration?.[name],
-          allowedValues: {
-            type: "objectQuery"
-          },
-          required: def.parameterConfiguration?.[name]?.required ?? true
-        },
-        defaultValue: def.parameterConfiguration?.[name]?.defaultValue,
-        description: def.parameterConfiguration?.[name]?.description
-      });
-      parameterSet.delete(MODIFY_OBJECT_PARAMETER);
+        validation: {
+          ...def.parameterConfiguration?.[name],
+          allowedValues: {
+            type: "objectQuery"
+          },
+          required: def.parameterConfiguration?.[name]?.required ?? true
+        },
+        defaultValue: def.parameterConfiguration?.[name]?.defaultValue,
+        description: def.parameterConfiguration?.[name]?.description
+      });
+      parameterSet.delete(MODIFY_OBJECT_PARAMETER);
     }
     if (name === CREATE_OR_MODIFY_OBJECT_PARAMETER) {
-      targetParam.push({
+      targetParams.push({
         id: CREATE_OR_MODIFY_OBJECT_PARAMETER,
         displayName: def.parameterConfiguration?.[name]?.displayName ?? "Create or modify object",
         type: {
           type: "objectReference",
           objectReference: {
             objectTypeId: def.objectType.apiName,
-            maybeCreateObjectOption: !def.primaryKeyOption || def.primaryKeyOption === "autoGenerated" ? {
+            maybeCreateObjectOption: !("primaryKeyOption" in def) ? {
+              type: "autoGenerated",
+              autoGenerated: {}
+            } : def.primaryKeyOption === "autoGenerated" ? {
               type: "autoGenerated",
               autoGenerated: {}
             } : {
@@ -2328,26 +2719,75 @@ function createParameters(def, parameterSet) {
       });
       parameterSet.delete(CREATE_OR_MODIFY_OBJECT_PARAMETER);
     }
-  });
-  return [...targetParam, ...Array.from(parameterSet).map((id) => ({
-    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],
-      allowedValues: def.parameterConfiguration?.[id].allowedValues ?? (def.parameterConfiguration?.[id].customParameterType ? extractAllowedValuesFromActionParameterType(def.parameterConfiguration?.[id].customParameterType) : extractAllowedValuesFromPropertyType(def.objectType.properties?.[id].type)),
-      required: def.parameterConfiguration?.[id].required ?? def.objectType.properties?.[id]?.nullability?.noNulls ?? false
-    } : {
-      required: def.objectType.properties?.[id].array ?? false ? {
-        listLength: def.objectType.properties?.[id].nullability?.noEmptyCollections ? {
-          min: 1
-        } : {}
-      } : def.objectType.properties?.[id].nullability?.noNulls ?? false,
-      allowedValues: extractAllowedValuesFromPropertyType(def.objectType.properties?.[id].type)
-    },
-    defaultValue: def.parameterConfiguration?.[id]?.defaultValue,
-    description: def.parameterConfiguration?.[id]?.description
-  }))];
+    if (name === CREATE_INTERFACE_OBJECT_PARAMETER && "interfaceType" in def) {
+      targetParams.push({
+        id: CREATE_INTERFACE_OBJECT_PARAMETER,
+        displayName: def.parameterConfiguration?.[name]?.displayName ?? "Object type to create",
+        type: {
+          type: "objectTypeReference",
+          objectTypeReference: {
+            interfaceTypeRids: [def.interfaceType.apiName]
+          }
+        },
+        validation: {
+          ...def.parameterConfiguration?.[name],
+          required: true,
+          allowedValues: def.objectType === void 0 ? {
+            type: "objectTypeReference",
+            interfaceTypes: [def.interfaceType.apiName]
+          } : {
+            type: "oneOf",
+            oneOf: [{
+              label: def.objectType.displayName,
+              value: {
+                type: "objectType",
+                objectType: {
+                  objectTypeId: def.objectType.apiName
+                }
+              }
+            }]
+          }
+        },
+        defaultValue: def.parameterConfiguration?.[name]?.defaultValue,
+        description: def.parameterConfiguration?.[name]?.description
+      });
+      parameterSet.delete(CREATE_INTERFACE_OBJECT_PARAMETER);
+    }
+    if (name === MODIFY_INTERFACE_OBJECT_PARAMETER && "interfaceType" in def) {
+      targetParams.push({
+        id: MODIFY_INTERFACE_OBJECT_PARAMETER,
+        displayName: def.parameterConfiguration?.[name]?.displayName ?? "Object type to modify",
+        type: {
+          type: "interfaceReference",
+          interfaceReference: {
+            interfaceTypeRid: def.interfaceType.apiName
+          }
+        },
+        validation: {
+          ...def.parameterConfiguration?.[name],
+          required: true,
+          allowedValues: def.objectType === void 0 ? {
+            type: "interfaceObjectQuery"
+          } : {
+            type: "oneOf",
+            oneOf: [{
+              label: def.objectType.displayName,
+              value: {
+                type: "objectType",
+                objectType: {
+                  objectTypeId: def.objectType.apiName
+                }
+              }
+            }]
+          }
+        },
+        defaultValue: def.parameterConfiguration?.[name]?.defaultValue,
+        description: def.parameterConfiguration?.[name]?.description
+      });
+      parameterSet.delete(MODIFY_INTERFACE_OBJECT_PARAMETER);
+    }
+  });
+  return targetParams;
 }
 function referencedParameterIds(actionDef) {
   const parameterIds = /* @__PURE__ */ new Set();
@@ -2612,104 +3052,425 @@ function kebab(s) {
 function sanitize(s) {
   return s.includes(".") ? s : namespace + s;
 }
-function convertValidationRule(actionValidation, objectProperties) {
+function convertValidationRule(actionValidation, actionParameters) {
   return actionValidation.map((rule) => {
     return {
-      condition: convertConditionDefinition(rule.condition, objectProperties),
+      condition: convertConditionDefinition(rule.condition, actionParameters),
       displayMetadata: rule.displayMetadata ?? {
         failureMessage: "Did not satisfy validation",
         typeClasses: []
       }
-    };
+    };
+  });
+}
+function validateActionConfiguration(action) {
+  const seenParameterIds = /* @__PURE__ */ new Set();
+  const parameterMap = action.parameters?.reduce((acc, param) => {
+    acc[param.id] = param;
+    return acc;
+  }, {}) ?? {};
+  const orderedParameters = action.parameterOrdering?.map((id) => parameterMap[id]) ?? action.parameters;
+  orderedParameters?.forEach((param) => {
+    param.validation.conditionalOverrides?.forEach((override) => {
+      validateParameterCondition(override.condition, param.id, seenParameterIds, action.parameters);
+    });
+    validateParameterPrefill(param.id, seenParameterIds, action.parameters, param.defaultValue);
+    seenParameterIds.add(param.id);
+  });
+}
+function validateParameterCondition(condition, currentParameterId, seenParameterIds, parameters) {
+  switch (condition.type) {
+    case "parameter":
+      const overrideParamId = condition.parameterId;
+      !parameters?.some((p) => p.id === overrideParamId) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Parameter condition on ${currentParameterId} is referencing unknown parameter ${overrideParamId}`) : invariant7__default.default(false) : void 0;
+      !(overrideParamId !== currentParameterId) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Parameter condition on ${currentParameterId} is referencing itself`) : invariant7__default.default(false) : void 0;
+      !seenParameterIds.has(overrideParamId) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Parameter condition on ${currentParameterId} is referencing later parameter ${overrideParamId}`) : invariant7__default.default(false) : void 0;
+      break;
+    case "and":
+      if ("conditions" in condition) {
+        condition.conditions.forEach((c) => validateParameterCondition(c, currentParameterId, seenParameterIds, parameters));
+      }
+      break;
+    case "or":
+      if ("conditions" in condition) {
+        condition.conditions.forEach((c) => validateParameterCondition(c, currentParameterId, seenParameterIds, parameters));
+      }
+      break;
+    case "comparison":
+    case "group":
+    case "not":
+    case "markings":
+    case "regex":
+    case "redacted":
+    case "true":
+      break;
+    default:
+      throw new Error(`Unknown condition type on parameter ${currentParameterId}`);
+  }
+}
+function validateParameterPrefill(currentParameterId, seenParameterIds, parameters, defaultValue) {
+  if (!defaultValue) return;
+  switch (defaultValue.type) {
+    case "objectParameterPropertyValue":
+      !parameters?.some((p) => p.id === defaultValue.objectParameterPropertyValue.parameterId) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Default value for parameter ${currentParameterId} is referencing unknown parameter ${defaultValue.objectParameterPropertyValue.parameterId}`) : invariant7__default.default(false) : void 0;
+      !seenParameterIds.has(defaultValue.objectParameterPropertyValue.parameterId) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Default value for parameter ${currentParameterId} is referencing later parameter ${defaultValue.objectParameterPropertyValue.parameterId}`) : invariant7__default.default(false) : void 0;
+      break;
+    case "staticValue":
+      !(defaultValue.staticValue.type === parameters?.find((p) => p.id === currentParameterId)?.type) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Default static value for parameter ${currentParameterId} does not match type`) : invariant7__default.default(false) : void 0;
+      break;
+    case "staticObject":
+    case "interfaceParameterPropertyValue":
+    case "objectQueryPrefill":
+    case "objectQueryPropertyValue":
+    case "objectSetRidPrefill":
+    case "redacted":
+      break;
+    default:
+      throw new Error(`Unknown default value type for parameter ${currentParameterId}`);
+  }
+}
+function validateActionParameters(def, properties, name) {
+  [...Object.keys(def.parameterConfiguration ?? {})].forEach((id) => {
+    !(properties.includes(id) || properties.includes(addNamespaceIfNone(id)) || def.parameterConfiguration?.[id].customParameterType !== void 0 || isTargetParameter(id)) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Parameter ${id} does not exist as a property on ${name} and its type is not explicitly defined`) : invariant7__default.default(false) : void 0;
+  });
+  [...Object.keys(def.nonParameterMappings ?? {}), ...def.excludedProperties ?? []].forEach((id) => {
+    !(properties.includes(id) || properties.includes(addNamespaceIfNone(id))) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Property ${id} does not exist as a property on ${name}`) : invariant7__default.default(false) : void 0;
+  });
+}
+function createDefaultParameterOrdering(def, properties, parameters, priorityId) {
+  return [...priorityId ? [priorityId] : [], ...Object.keys(def.parameterConfiguration ?? {}).filter((id) => id !== priorityId), ...properties.filter((id) => !def.parameterConfiguration?.[id] && parameters.some((p) => p.id === id))];
+}
+function validateParameterOrdering(parameterOrdering, parameterSet, actionApiName) {
+  const orderingSet = new Set(parameterOrdering);
+  const missingParameters = [...parameterSet].filter((param) => !orderingSet.has(param));
+  const extraneousParameters = parameterOrdering.filter((param) => !parameterSet.has(param));
+  !(extraneousParameters.length === 0 && missingParameters.length === 0) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Action parameter ordering for ${actionApiName} does not match expected parameters. Extraneous parameters in ordering: {${extraneousParameters}}, Missing parameters in ordering: {${missingParameters}}`) : invariant7__default.default(false) : void 0;
+}
+function isTargetParameter(parameterId) {
+  return parameterId === MODIFY_OBJECT_PARAMETER || parameterId === CREATE_OR_MODIFY_OBJECT_PARAMETER || parameterId === CREATE_INTERFACE_OBJECT_PARAMETER || parameterId === MODIFY_INTERFACE_OBJECT_PARAMETER;
+}
+function addNamespaceToActionDefinition(def) {
+  def.parameterConfiguration = Object.fromEntries(Object.entries(def.parameterConfiguration ?? {}).map(([id, config]) => [getInterfaceParameterName(def, id), config]));
+  def.nonParameterMappings = Object.fromEntries(Object.entries(def.nonParameterMappings ?? {}).map(([id, value]) => [addNamespaceIfNone(id), value]));
+  def.excludedProperties = (def.excludedProperties ?? []).map((id) => addNamespaceIfNone(id));
+  def.sections = def.sections?.map((section) => ({
+    ...section,
+    parameters: section.parameters.map((p) => getInterfaceParameterName(def, p))
+  }));
+}
+function getInterfaceParameterName(def, parameter) {
+  return isTargetParameter(parameter) || !Object.keys(def.interfaceType.propertiesV2).includes(addNamespaceIfNone(parameter)) ? parameter : addNamespaceIfNone(parameter);
+}
+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/defineCreateInterfaceObjectAction.ts
+function defineCreateInterfaceObjectAction(def) {
+  addNamespaceToActionDefinition(def);
+  const allProperties = getFlattenedInterfaceProperties(def.interfaceType);
+  validateActionParameters(def, Object.keys(allProperties), def.interfaceType.apiName);
+  const propertyParameters = Object.keys(allProperties).filter((apiName) => isPropertyParameter(def, apiName, allProperties[apiName].sharedPropertyType.type));
+  const parameterNames = new Set(propertyParameters);
+  Object.keys(def.parameterConfiguration ?? {}).forEach((param) => parameterNames.add(getInterfaceParameterName(def, param)));
+  parameterNames.add(CREATE_INTERFACE_OBJECT_PARAMETER);
+  const actionApiName = def.apiName ?? `create-${kebab(def.interfaceType.apiName.split(".").pop() ?? def.interfaceType.apiName)}${def.objectType === void 0 ? "" : `-${kebab(def.objectType.apiName.split(".").pop() ?? def.objectType.apiName)}`}`;
+  if (def.parameterOrdering) {
+    if (!def.parameterOrdering.includes(CREATE_INTERFACE_OBJECT_PARAMETER)) {
+      def.parameterOrdering.unshift(CREATE_INTERFACE_OBJECT_PARAMETER);
+    }
+    validateParameterOrdering(def.parameterOrdering, parameterNames, actionApiName);
+  }
+  const parameters = createParameters(def, Object.fromEntries(Object.entries(allProperties).map(([id, prop]) => [id, prop.sharedPropertyType])), parameterNames, Object.fromEntries(Object.entries(allProperties).map(([id, prop]) => [id, prop.required])));
+  const mappings = Object.fromEntries(Object.entries(def.nonParameterMappings ?? {}).map(([id, value]) => [id, convertMappingValue(value)]));
+  return defineAction({
+    apiName: actionApiName,
+    displayName: def.displayName ?? `Create ${def.interfaceType.displayMetadata.displayName}`,
+    parameters,
+    status: def.status ?? (def.interfaceType.status.type !== "deprecated" ? def.interfaceType.status.type : def.interfaceType.status),
+    entities: {
+      affectedInterfaceTypes: [def.interfaceType.apiName],
+      affectedObjectTypes: [],
+      affectedLinkTypes: [],
+      typeGroups: []
+    },
+    rules: [{
+      type: "addInterfaceRule",
+      addInterfaceRule: {
+        interfaceApiName: def.interfaceType.apiName,
+        objectTypeParameter: CREATE_INTERFACE_OBJECT_PARAMETER,
+        sharedPropertyValues: {
+          ...Object.fromEntries(propertyParameters.map((id) => [id, {
+            type: "parameterId",
+            parameterId: id
+          }])),
+          ...mappings
+        }
+      }
+    }],
+    parameterOrdering: def.parameterOrdering ?? createDefaultParameterOrdering(def, Object.keys(allProperties), parameters, CREATE_INTERFACE_OBJECT_PARAMETER),
+    ...def.actionLevelValidation ? {
+      validation: convertValidationRule(def.actionLevelValidation, parameters)
+    } : {},
+    ...def.defaultFormat && {
+      defaultFormat: def.defaultFormat
+    },
+    ...def.enableLayoutSwitch && {
+      enableLayoutSwitch: def.enableLayoutSwitch
+    },
+    ...def.tableConfiguration && {
+      displayAndFormat: {
+        table: def.tableConfiguration
+      }
+    },
+    ...def.sections && {
+      sections: Object.fromEntries(def.sections.map((section) => [section.id, section]))
+    },
+    ...def.submissionMetadata && {
+      submissionMetadata: def.submissionMetadata
+    }
+  });
+}
+
+// src/api/defineCreateObjectAction.ts
+function defineCreateObjectAction(def) {
+  validateActionParameters(def, Object.keys(def.objectType.properties ?? {}), def.objectType.apiName);
+  const propertiesWithDerivedDatasources = (def.objectType.datasources ?? []).filter((ds) => ds.type === "derived").flatMap((ds) => Object.keys(ds.propertyMapping));
+  const propertyParameters = Object.keys(def.objectType.properties ?? {}).filter((id) => isPropertyParameter(def, id, def.objectType.properties?.[id].type) && !isStruct(def.objectType.properties?.[id].type) && !propertiesWithDerivedDatasources.includes(id));
+  const parameterNames = new Set(propertyParameters);
+  Object.keys(def.parameterConfiguration ?? {}).forEach((param) => parameterNames.add(param));
+  const actionApiName = def.apiName ?? `create-object-${kebab(def.objectType.apiName.split(".").pop() ?? def.objectType.apiName)}`;
+  if (def.parameterOrdering) {
+    validateParameterOrdering(def.parameterOrdering, parameterNames, actionApiName);
+  }
+  const parameters = createParameters(def, def.objectType.properties ?? {}, parameterNames);
+  const mappings = Object.fromEntries(Object.entries(def.nonParameterMappings ?? {}).map(([id, value]) => [id, convertMappingValue(value)]));
+  return defineAction({
+    apiName: actionApiName,
+    displayName: def.displayName ?? `Create ${def.objectType.displayName}`,
+    parameters,
+    status: def.status ?? "active",
+    entities: {
+      affectedInterfaceTypes: [],
+      affectedObjectTypes: [def.objectType.apiName],
+      affectedLinkTypes: [],
+      typeGroups: []
+    },
+    rules: [{
+      type: "addObjectRule",
+      addObjectRule: {
+        objectTypeId: def.objectType.apiName,
+        propertyValues: {
+          ...Object.fromEntries(propertyParameters.map((p) => [p, {
+            type: "parameterId",
+            parameterId: p
+          }])),
+          ...mappings
+        },
+        structFieldValues: {}
+      }
+    }],
+    parameterOrdering: def.parameterOrdering ?? createDefaultParameterOrdering(def, Object.keys(def.objectType.properties ?? {}), parameters),
+    ...def.actionLevelValidation ? {
+      validation: convertValidationRule(def.actionLevelValidation, parameters)
+    } : {},
+    ...def.defaultFormat && {
+      defaultFormat: def.defaultFormat
+    },
+    ...def.enableLayoutSwitch && {
+      enableLayoutSwitch: def.enableLayoutSwitch
+    },
+    ...def.tableConfiguration && {
+      displayAndFormat: {
+        table: def.tableConfiguration
+      }
+    },
+    ...def.sections && {
+      sections: Object.fromEntries(def.sections.map((section) => [section.id, section]))
+    },
+    ...def.submissionMetadata && {
+      submissionMetadata: def.submissionMetadata
+    }
+  });
+}
+
+// src/api/defineCreateOrModifyObjectAction.ts
+function defineCreateOrModifyObjectAction(def) {
+  validateActionParameters(def, Object.keys(def.objectType.properties ?? {}), def.objectType.apiName);
+  const propertiesWithDerivedDatasources = (def.objectType.datasources ?? []).filter((ds) => ds.type === "derived").flatMap((ds) => Object.keys(ds.propertyMapping));
+  const propertyParameters = Object.keys(def.objectType.properties ?? {}).filter((id) => !Object.keys(def.nonParameterMappings ?? {}).includes(id) && !def.excludedProperties?.includes(id) && !isStruct(def.objectType.properties?.[id].type) && id !== def.objectType.primaryKeyPropertyApiName && !propertiesWithDerivedDatasources.includes(id));
+  const parameterNames = new Set(propertyParameters);
+  Object.keys(def.parameterConfiguration ?? {}).forEach((param) => parameterNames.add(param));
+  parameterNames.add(CREATE_OR_MODIFY_OBJECT_PARAMETER);
+  const actionApiName = def.apiName ?? `create-or-modify-${kebab(def.objectType.apiName.split(".").pop() ?? def.objectType.apiName)}`;
+  if (def.parameterOrdering) {
+    if (!def.parameterOrdering.includes(CREATE_OR_MODIFY_OBJECT_PARAMETER)) {
+      def.parameterOrdering.unshift(CREATE_OR_MODIFY_OBJECT_PARAMETER);
+    }
+    validateParameterOrdering(def.parameterOrdering, parameterNames, actionApiName);
+  }
+  const parameters = createParameters(def, def.objectType.properties ?? {}, parameterNames);
+  parameters.forEach((p) => {
+    if (p.id !== CREATE_OR_MODIFY_OBJECT_PARAMETER && p.defaultValue === void 0) {
+      p.defaultValue = {
+        type: "objectParameterPropertyValue",
+        objectParameterPropertyValue: {
+          parameterId: CREATE_OR_MODIFY_OBJECT_PARAMETER,
+          propertyTypeId: p.id
+        }
+      };
+    }
+  });
+  const mappings = Object.fromEntries(Object.entries(def.nonParameterMappings ?? {}).map(([id, value]) => [id, convertMappingValue(value)]));
+  return defineAction({
+    apiName: actionApiName,
+    displayName: def.displayName ?? `Create or Modify ${def.objectType.displayName}`,
+    parameters,
+    status: def.status ?? "active",
+    rules: [{
+      type: "addOrModifyObjectRuleV2",
+      addOrModifyObjectRuleV2: {
+        objectToModify: CREATE_OR_MODIFY_OBJECT_PARAMETER,
+        propertyValues: {
+          ...Object.fromEntries(propertyParameters.map((p) => [p, {
+            type: "parameterId",
+            parameterId: p
+          }])),
+          ...mappings
+        },
+        structFieldValues: {}
+      }
+    }],
+    entities: {
+      affectedInterfaceTypes: [],
+      affectedObjectTypes: [def.objectType.apiName],
+      affectedLinkTypes: [],
+      typeGroups: []
+    },
+    parameterOrdering: def.parameterOrdering ?? createDefaultParameterOrdering(def, Object.keys(def.objectType.properties ?? {}), parameters, CREATE_OR_MODIFY_OBJECT_PARAMETER),
+    ...def.actionLevelValidation ? {
+      validation: convertValidationRule(def.actionLevelValidation, parameters)
+    } : {},
+    ...def.defaultFormat && {
+      defaultFormat: def.defaultFormat
+    },
+    ...def.enableLayoutSwitch && {
+      enableLayoutSwitch: def.enableLayoutSwitch
+    },
+    ...def.tableConfiguration && {
+      displayAndFormat: {
+        table: def.tableConfiguration
+      }
+    },
+    ...def.sections && {
+      sections: Object.fromEntries(def.sections.map((section) => [section.id, section]))
+    },
+    ...def.submissionMetadata && {
+      submissionMetadata: def.submissionMetadata
+    }
   });
 }
-function validateActionConfiguration(action) {
-  const seenParameterIds = /* @__PURE__ */ new Set();
-  const parameterMap = action.parameters?.reduce((acc, param) => {
-    acc[param.id] = param;
-    return acc;
-  }, {}) ?? {};
-  const orderedParameters = action.parameterOrdering?.map((id) => parameterMap[id]) ?? action.parameters;
-  orderedParameters?.forEach((param) => {
-    param.validation.conditionalOverrides?.forEach((override) => {
-      validateParameterCondition(override.condition, param.id, seenParameterIds, action.parameters);
-    });
-    validateParameterPrefill(param.id, seenParameterIds, action.parameters, param.defaultValue);
-    seenParameterIds.add(param.id);
+
+// src/api/defineDeleteInterfaceObjectAction.ts
+function defineDeleteInterfaceObjectAction(def) {
+  return defineAction({
+    apiName: def.apiName ?? `delete-interface-object-${kebab(def.interfaceType.apiName.split(".").pop() ?? def.interfaceType.apiName)}`,
+    displayName: def.displayName ?? `Delete ${def.interfaceType.displayMetadata.displayName}`,
+    parameters: [{
+      id: "objectToDeleteParameter",
+      displayName: "Delete object",
+      type: {
+        type: "interfaceReference",
+        interfaceReference: {
+          interfaceTypeRid: def.interfaceType.apiName
+        }
+      },
+      validation: {
+        required: true,
+        allowedValues: {
+          type: "interfaceObjectQuery"
+        }
+      }
+    }],
+    status: def.status ?? "active",
+    rules: [{
+      type: "deleteObjectRule",
+      deleteObjectRule: {
+        objectToDelete: "objectToDeleteParameter"
+      }
+    }],
+    entities: {
+      affectedInterfaceTypes: [def.interfaceType.apiName],
+      affectedObjectTypes: [],
+      affectedLinkTypes: [],
+      typeGroups: []
+    }
   });
 }
-function validateParameterCondition(condition, currentParameterId, seenParameterIds, parameters) {
-  switch (condition.type) {
-    case "parameter":
-      const overrideParamId = condition.parameterId;
-      !parameters?.some((p) => p.id === overrideParamId) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Parameter condition on ${currentParameterId} is referencing unknown parameter ${overrideParamId}`) : invariant6__default.default(false) : void 0;
-      !(overrideParamId !== currentParameterId) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Parameter condition on ${currentParameterId} is referencing itself`) : invariant6__default.default(false) : void 0;
-      !seenParameterIds.has(overrideParamId) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Parameter condition on ${currentParameterId} is referencing later parameter ${overrideParamId}`) : invariant6__default.default(false) : void 0;
-      break;
-    case "and":
-      if ("conditions" in condition) {
-        condition.conditions.forEach((c) => validateParameterCondition(c, currentParameterId, seenParameterIds, parameters));
+
+// src/api/defineDeleteObjectAction.ts
+function defineDeleteObjectAction(def) {
+  return defineAction({
+    apiName: def.apiName ?? `delete-object-${kebab(def.objectType.apiName.split(".").pop() ?? def.objectType.apiName)}`,
+    displayName: def.displayName ?? `Delete ${def.objectType.displayName}`,
+    parameters: [{
+      id: "objectToDeleteParameter",
+      displayName: "Delete object",
+      type: {
+        type: "objectReference",
+        objectReference: {
+          objectTypeId: def.objectType.apiName
+        }
+      },
+      validation: {
+        required: true,
+        allowedValues: {
+          type: "objectQuery"
+        }
       }
-      break;
-    case "or":
-      if ("conditions" in condition) {
-        condition.conditions.forEach((c) => validateParameterCondition(c, currentParameterId, seenParameterIds, parameters));
+    }],
+    status: def.status ?? "active",
+    rules: [{
+      type: "deleteObjectRule",
+      deleteObjectRule: {
+        objectToDelete: "objectToDeleteParameter"
       }
-      break;
-    case "comparison":
-    case "group":
-    case "not":
-    case "markings":
-    case "regex":
-    case "redacted":
-    case "true":
-      break;
-    default:
-      throw new Error(`Unknown condition type on parameter ${currentParameterId}`);
-  }
-}
-function validateParameterPrefill(currentParameterId, seenParameterIds, parameters, defaultValue) {
-  if (!defaultValue) return;
-  switch (defaultValue.type) {
-    case "objectParameterPropertyValue":
-      !parameters?.some((p) => p.id === defaultValue.objectParameterPropertyValue.parameterId) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Default value for parameter ${currentParameterId} is referencing unknown parameter ${defaultValue.objectParameterPropertyValue.parameterId}`) : invariant6__default.default(false) : void 0;
-      !seenParameterIds.has(defaultValue.objectParameterPropertyValue.parameterId) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Default value for parameter ${currentParameterId} is referencing later parameter ${defaultValue.objectParameterPropertyValue.parameterId}`) : invariant6__default.default(false) : void 0;
-      break;
-    case "staticValue":
-      !(defaultValue.staticValue.type === parameters?.find((p) => p.id === currentParameterId)?.type) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Default static value for parameter ${currentParameterId} does not match type`) : invariant6__default.default(false) : void 0;
-      break;
-    case "staticObject":
-    case "interfaceParameterPropertyValue":
-    case "objectQueryPrefill":
-    case "objectQueryPropertyValue":
-    case "objectSetRidPrefill":
-    case "redacted":
-      break;
-    default:
-      throw new Error(`Unknown default value type for parameter ${currentParameterId}`);
-  }
-}
-function validateActionParameters(def) {
-  [...Object.keys(def.parameterConfiguration ?? {})].forEach((id) => {
-    !(def.objectType.properties?.[id] !== void 0 || def.parameterConfiguration?.[id].customParameterType !== void 0 || id === MODIFY_OBJECT_PARAMETER || id === CREATE_OR_MODIFY_OBJECT_PARAMETER) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Parameter ${id} does not exist as a property on ${def.objectType.apiName} and its type is not explicitly defined`) : invariant6__default.default(false) : void 0;
-  });
-  [...Object.keys(def.nonParameterMappings ?? {}), ...def.excludedProperties ?? []].forEach((id) => {
-    !(def.objectType.properties?.[id] !== void 0) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Property ${id} does not exist as a property on ${def.objectType.apiName}`) : invariant6__default.default(false) : void 0;
+    }],
+    entities: {
+      affectedInterfaceTypes: [],
+      affectedObjectTypes: [def.objectType.apiName],
+      affectedLinkTypes: [],
+      typeGroups: []
+    },
+    ...def.actionLevelValidation ? {
+      validation: convertValidationRule(def.actionLevelValidation)
+    } : {}
   });
 }
-function createDefaultParameterOrdering(def, parameters, priorityId) {
-  return [...priorityId ? [priorityId] : [], ...Object.keys(def.parameterConfiguration ?? {}), ...Object.keys(def.objectType.properties ?? {}).filter((id) => !def.parameterConfiguration?.[id] && parameters.some((p) => p.id === id))];
-}
-function validateParameterOrdering(parameterOrdering, parameterSet, actionApiName) {
-  const orderingSet = new Set(parameterOrdering);
-  const missingParameters = [...parameterSet].filter((param) => !orderingSet.has(param));
-  const extraneousParameters = parameterOrdering.filter((param) => !parameterSet.has(param));
-  !(extraneousParameters.length === 0 && missingParameters.length === 0) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Action parameter ordering for ${actionApiName} does not match expected parameters. Extraneous parameters in ordering: {${extraneousParameters}}, Missing parameters in ordering: {${missingParameters}}`) : invariant6__default.default(false) : void 0;
-}
 function defineSharedPropertyType(sptDef) {
   const apiName = namespace + sptDef.apiName;
-  !(ontologyDefinition[OntologyEntityTypeEnum.SHARED_PROPERTY_TYPE][apiName] === void 0) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Shared property type ${apiName} already exists`) : invariant6__default.default(false) : void 0;
-  !(!shouldNotHaveRenderHints(sptDef.type) || !hasRenderHints(sptDef.typeClasses)) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Shared property type ${apiName} of type '${getPropertyTypeName(sptDef.type)}' should not have render hints`) : invariant6__default.default(false) : void 0;
+  !(ontologyDefinition[OntologyEntityTypeEnum.SHARED_PROPERTY_TYPE][apiName] === void 0) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Shared property type ${apiName} already exists`) : invariant7__default.default(false) : void 0;
+  !(!shouldNotHaveRenderHints(sptDef.type) || !hasRenderHints(sptDef.typeClasses)) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Shared property type ${apiName} of type '${getPropertyTypeName(sptDef.type)}' should not have render hints`) : invariant7__default.default(false) : void 0;
   const fullSpt = {
     ...sptDef,
     apiName,
@@ -2758,7 +3519,7 @@ function combineApiNamespaceIfMissing(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" ? invariant6__default.default(false, `Interface ${apiName} already exists`) : invariant6__default.default(false) : void 0;
+  !(ontologyDefinition[OntologyEntityTypeEnum.INTERFACE_TYPE][apiName] === void 0) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Interface ${apiName} already exists`) : invariant7__default.default(false) : void 0;
   const properties = Object.fromEntries(Object.entries(interfaceDef.properties ?? {}).map(([unNamespacedPropApiName, type]) => {
     if (typeof type === "object" && "propertyDefinition" in type) {
       const apiName3 = combineApiNamespaceIfMissing(namespace, typeof type.propertyDefinition === "object" && "apiName" in type.propertyDefinition ? type.propertyDefinition.apiName : unNamespacedPropApiName);
@@ -2777,7 +3538,7 @@ function defineInterface(interfaceDef) {
   const status = mapSimplifiedStatusToInterfaceTypeStatus(interfaceDef.status ?? {
     type: "active"
   });
-  !(status.type !== "deprecated" || status.deprecated.message && status.deprecated.deadline) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Deprecated status must include message and deadline properties.`) : invariant6__default.default(false) : void 0;
+  !(status.type !== "deprecated" || status.deprecated.message && status.deprecated.deadline) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Deprecated status must include message and deadline properties.`) : invariant7__default.default(false) : void 0;
   const fullInterface = {
     apiName,
     displayMetadata: {
@@ -2803,7 +3564,7 @@ function defineInterface(interfaceDef) {
 }
 function unifyBasePropertyDefinition(namespace2, apiName, type) {
   if (typeof type === "string" || typeof type === "object" && !("apiName" in type)) {
-    !isPropertyTypeType(type) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Invalid data type ${JSON.stringify(type)} for property ${apiName} on InterfaceType ${apiName}`) : invariant6__default.default(false) : void 0;
+    !isPropertyTypeType(type) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Invalid data type ${JSON.stringify(type)} for property ${apiName} on InterfaceType ${apiName}`) : invariant7__default.default(false) : void 0;
     const spt = defineSharedPropertyType({
       apiName,
       displayName: apiName,
@@ -2813,16 +3574,16 @@ function unifyBasePropertyDefinition(namespace2, apiName, type) {
     return spt;
   } else {
     const unNamespacedTypeApiName = withoutNamespace(type.apiName);
-    !(namespace2 + apiName === type.apiName || apiName === unNamespacedTypeApiName) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `property key and it's apiName must be identical. ${JSON.stringify({
+    !(namespace2 + apiName === type.apiName || apiName === unNamespacedTypeApiName) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `property key and it's apiName must be identical. ${JSON.stringify({
       key: apiName,
       apiName: type.apiName
-    })}`) : invariant6__default.default(false) : void 0;
+    })}`) : invariant7__default.default(false) : void 0;
     return type;
   }
 }
 function defineInterfaceLinkConstraint(linkDef) {
   const fromLinkMeta = getLinkMeta(linkDef);
-  !(linkDef.from.links.find((a) => a.metadata.apiName === fromLinkMeta.apiName) == null) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Link with apiName ${fromLinkMeta.apiName} already exists on ${linkDef.apiName}`) : invariant6__default.default(false) : void 0;
+  !(linkDef.from.links.find((a) => a.metadata.apiName === fromLinkMeta.apiName) == null) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Link with apiName ${fromLinkMeta.apiName} already exists on ${linkDef.apiName}`) : invariant7__default.default(false) : void 0;
   linkDef.from.links.push({
     cardinality: linkDef.toMany ? "MANY" : "SINGLE",
     linkedEntityTypeId: getLinkedType(linkDef.toMany ?? linkDef.toOne),
@@ -2850,19 +3611,9 @@ function getLinkMeta(meta) {
     description: description ?? displayName ?? apiNameWithoutNamespace
   };
 }
-var typeIdPattern = /([a-z][a-z0-9\\-]*)/;
+
+// src/api/defineLink.ts
 function defineLink(linkDefinition) {
-  if ("one" in linkDefinition) {
-    const foreignKey = linkDefinition.toMany.object.properties?.[linkDefinition.manyForeignKeyProperty];
-    !(foreignKey !== void 0) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Foreign key ${linkDefinition.manyForeignKeyProperty} on link ${linkDefinition.apiName} does not exist on object ${linkDefinition.toMany.object.apiName}}`) : invariant6__default.default(false) : void 0;
-    !typeIdPattern.test(linkDefinition.apiName) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Top level link api names are expected to match the regex pattern ([a-z][a-z0-9\\-]*) ${linkDefinition.apiName} does not match`) : invariant6__default.default(false) : void 0;
-    const typesMatch = foreignKey.type === linkDefinition.one.object.properties?.[linkDefinition.one.object.primaryKeyPropertyApiName].type;
-    !typesMatch ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Link ${linkDefinition.apiName} has type mismatch between the one side's primary key and the foreign key on the many side`) : invariant6__default.default(false) : void 0;
-  }
-  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" ? invariant6__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}`) : invariant6__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" ? invariant6__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}`) : invariant6__default.default(false) : void 0;
-  }
   let fullLinkDefinition;
   if ("one" in linkDefinition) {
     fullLinkDefinition = {
@@ -2886,6 +3637,7 @@ function defineLink(linkDefinition) {
   const linkType = {
     cardinality: "one" in linkDefinition ? linkDefinition.cardinality : void 0,
     ...fullLinkDefinition,
+    apiName: linkDefinition.apiName,
     __type: OntologyEntityTypeEnum.LINK_TYPE
   };
   updateOntology(linkType);
@@ -2921,6 +3673,148 @@ function convertLinkTypeMetadata(metadata) {
     typeClasses: []
   };
 }
+
+// src/api/defineModifyInterfaceObjectAction.ts
+function defineModifyInterfaceObjectAction(def) {
+  addNamespaceToActionDefinition(def);
+  const allProperties = getFlattenedInterfaceProperties(def.interfaceType);
+  validateActionParameters(def, Object.keys(allProperties), def.interfaceType.apiName);
+  const propertyParameters = Object.keys(allProperties).filter((apiName) => isPropertyParameter(def, apiName, allProperties[apiName].sharedPropertyType.type));
+  const parameterNames = new Set(propertyParameters);
+  Object.keys(def.parameterConfiguration ?? {}).forEach((param) => parameterNames.add(getInterfaceParameterName(def, param)));
+  parameterNames.add(MODIFY_INTERFACE_OBJECT_PARAMETER);
+  const actionApiName = def.apiName ?? `modify-${kebab(def.interfaceType.apiName.split(".").pop() ?? def.interfaceType.apiName)}${def.objectType === void 0 ? "" : `-${kebab(def.objectType.apiName.split(".").pop() ?? def.objectType.apiName)}`}`;
+  if (def.parameterOrdering) {
+    if (!def.parameterOrdering.includes(MODIFY_INTERFACE_OBJECT_PARAMETER)) {
+      def.parameterOrdering.unshift(MODIFY_INTERFACE_OBJECT_PARAMETER);
+    }
+    validateParameterOrdering(def.parameterOrdering, parameterNames, actionApiName);
+  }
+  const parameters = createParameters(def, Object.fromEntries(Object.entries(allProperties).map(([id, prop]) => [id, prop.sharedPropertyType])), parameterNames, Object.fromEntries(Object.entries(allProperties).map(([id, prop]) => [id, prop.required])));
+  const mappings = Object.fromEntries(Object.entries(def.nonParameterMappings ?? {}).map(([id, value]) => [id, convertMappingValue(value)]));
+  return defineAction({
+    apiName: actionApiName,
+    displayName: def.displayName ?? `Modify ${def.interfaceType.displayMetadata.displayName}`,
+    parameters,
+    status: def.status ?? (def.interfaceType.status.type !== "deprecated" ? def.interfaceType.status.type : def.interfaceType.status),
+    entities: {
+      affectedInterfaceTypes: [def.interfaceType.apiName],
+      affectedObjectTypes: [],
+      affectedLinkTypes: [],
+      typeGroups: []
+    },
+    rules: [{
+      type: "modifyInterfaceRule",
+      modifyInterfaceRule: {
+        interfaceObjectToModifyParameter: "interfaceObjectToModifyParameter",
+        sharedPropertyValues: {
+          ...Object.fromEntries(propertyParameters.map((id) => [id, {
+            type: "parameterId",
+            parameterId: id
+          }])),
+          ...mappings
+        }
+      }
+    }],
+    parameterOrdering: def.parameterOrdering ?? createDefaultParameterOrdering(def, Object.keys(allProperties), parameters, MODIFY_INTERFACE_OBJECT_PARAMETER),
+    ...def.actionLevelValidation ? {
+      validation: convertValidationRule(def.actionLevelValidation, parameters)
+    } : {},
+    ...def.defaultFormat && {
+      defaultFormat: def.defaultFormat
+    },
+    ...def.enableLayoutSwitch && {
+      enableLayoutSwitch: def.enableLayoutSwitch
+    },
+    ...def.tableConfiguration && {
+      displayAndFormat: {
+        table: def.tableConfiguration
+      }
+    },
+    ...def.sections && {
+      sections: Object.fromEntries(def.sections.map((section) => [section.id, section]))
+    },
+    ...def.submissionMetadata && {
+      submissionMetadata: def.submissionMetadata
+    }
+  });
+}
+
+// src/api/defineModifyObjectAction.ts
+function defineModifyObjectAction(def) {
+  validateActionParameters(def, Object.keys(def.objectType.properties ?? {}), def.objectType.apiName);
+  const propertyParameters = Object.keys(def.objectType.properties ?? {}).filter((id) => isPropertyParameter(def, id, def.objectType.properties?.[id].type) && id !== def.objectType.primaryKeyPropertyApiName);
+  const parameterNames = new Set(propertyParameters);
+  Object.keys(def.parameterConfiguration ?? {}).forEach((param) => parameterNames.add(param));
+  parameterNames.add(MODIFY_OBJECT_PARAMETER);
+  const actionApiName = def.apiName ?? `modify-object-${kebab(def.objectType.apiName.split(".").pop() ?? def.objectType.apiName)}`;
+  if (def.parameterOrdering) {
+    if (!def.parameterOrdering.includes(MODIFY_OBJECT_PARAMETER)) {
+      def.parameterOrdering.unshift(MODIFY_OBJECT_PARAMETER);
+    }
+    validateParameterOrdering(def.parameterOrdering, parameterNames, actionApiName);
+  }
+  const parameters = createParameters(def, def.objectType.properties ?? {}, parameterNames);
+  parameters.forEach((p) => {
+    if (p.id !== MODIFY_OBJECT_PARAMETER && p.defaultValue === void 0) {
+      p.defaultValue = {
+        type: "objectParameterPropertyValue",
+        objectParameterPropertyValue: {
+          parameterId: MODIFY_OBJECT_PARAMETER,
+          propertyTypeId: p.id
+        }
+      };
+    }
+  });
+  const mappings = Object.fromEntries(Object.entries(def.nonParameterMappings ?? {}).map(([id, value]) => [id, convertMappingValue(value)]));
+  return defineAction({
+    apiName: actionApiName,
+    displayName: def.displayName ?? `Modify ${def.objectType.displayName}`,
+    parameters,
+    status: def.status ?? "active",
+    rules: [{
+      type: "modifyObjectRule",
+      modifyObjectRule: {
+        objectToModify: MODIFY_OBJECT_PARAMETER,
+        propertyValues: {
+          ...Object.fromEntries(propertyParameters.map((p) => [p, {
+            type: "parameterId",
+            parameterId: p
+          }])),
+          ...mappings
+        },
+        structFieldValues: {}
+      }
+    }],
+    entities: {
+      affectedInterfaceTypes: [],
+      affectedObjectTypes: [def.objectType.apiName],
+      affectedLinkTypes: [],
+      typeGroups: []
+    },
+    parameterOrdering: def.parameterOrdering ?? createDefaultParameterOrdering(def, Object.keys(def.objectType.properties ?? {}), parameters, MODIFY_OBJECT_PARAMETER),
+    ...def.actionLevelValidation ? {
+      validation: convertValidationRule(def.actionLevelValidation, parameters)
+    } : {},
+    ...def.defaultFormat && {
+      defaultFormat: def.defaultFormat
+    },
+    ...def.enableLayoutSwitch && {
+      enableLayoutSwitch: def.enableLayoutSwitch
+    },
+    ...def.tableConfiguration && {
+      displayAndFormat: {
+        table: def.tableConfiguration
+      }
+    },
+    ...def.sections && {
+      sections: Object.fromEntries(def.sections.map((section) => [section.id, section]))
+    },
+    ...def.submissionMetadata && {
+      submissionMetadata: def.submissionMetadata
+    }
+  });
+}
 function convertValueTypeTypeToBaseType(valueType) {
   switch (true) {
     case (typeof valueType === "object" && valueType.type === "array"):
@@ -2973,7 +3867,7 @@ function defineValueType(valueTypeDef) {
     version
   } = valueTypeDef;
   const semverValidation = /^((([0-9]+)\.([0-9]+)\.([0-9]+)(?:-([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?)(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?)$/;
-  !semverValidation.test(version) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, "Version is not a valid semver") : invariant6__default.default(false) : void 0;
+  !semverValidation.test(version) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, "Version is not a valid semver") : invariant7__default.default(false) : void 0;
   const typeName = typeof type.type === "string" ? type.type : type.type.type === "struct" ? "structV2" : type.type.type;
   const constraints = type.constraints ? type.constraints.map((constraint) => {
     const output = {
@@ -3029,8 +3923,8 @@ function importSharedPropertyType(opts) {
   } = opts;
   const fullApiName = packageName === void 0 ? apiName : `${packageName}.${apiName}`;
   if (packageName !== void 0) {
-    !!packageName.endsWith(".") ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, "Package name format invalid ends with period") : invariant6__default.default(false) : void 0;
-    !(packageName.match("[A-Z]") == null) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, "Package name includes upper case characters") : invariant6__default.default(false) : void 0;
+    !!packageName.endsWith(".") ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, "Package name format invalid ends with period") : invariant7__default.default(false) : void 0;
+    !(packageName.match("[A-Z]") == null) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, "Package name includes upper case characters") : invariant7__default.default(false) : void 0;
   }
   const spt = {
     apiName: fullApiName,
@@ -3052,8 +3946,18 @@ function wrapWithProxy(entity) {
     }
   });
 }
+/*! Bundled license information:
+
+mustache/mustache.mjs:
+  (*!
+   * mustache.js - Logic-less {{mustache}} templates with JavaScript
+   * http://github.com/janl/mustache.js
+   *)
+*/
 
+exports.CREATE_INTERFACE_OBJECT_PARAMETER = CREATE_INTERFACE_OBJECT_PARAMETER;
 exports.CREATE_OR_MODIFY_OBJECT_PARAMETER = CREATE_OR_MODIFY_OBJECT_PARAMETER;
+exports.MODIFY_INTERFACE_OBJECT_PARAMETER = MODIFY_INTERFACE_OBJECT_PARAMETER;
 exports.MODIFY_OBJECT_PARAMETER = MODIFY_OBJECT_PARAMETER;
 exports.OntologyEntityTypeEnum = OntologyEntityTypeEnum;
 exports.addDependency = addDependency;
@@ -3066,6 +3970,7 @@ exports.defineAction = defineAction;
 exports.defineCreateInterfaceObjectAction = defineCreateInterfaceObjectAction;
 exports.defineCreateObjectAction = defineCreateObjectAction;
 exports.defineCreateOrModifyObjectAction = defineCreateOrModifyObjectAction;
+exports.defineDeleteInterfaceObjectAction = defineDeleteInterfaceObjectAction;
 exports.defineDeleteObjectAction = defineDeleteObjectAction;
 exports.defineInterface = defineInterface;
 exports.defineInterfaceLinkConstraint = defineInterfaceLinkConstraint;